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

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

Browse Source
example_keyboards
IBNobody 8 years ago
parent 76e36a787a 287eb7ad14
commit 26277dbdf4
32 changed files with 626 additions and 792 deletions
Show Stats Download Patch File Download Diff File

6
HAND_WIRE.md
Unescape Escape View File

@ -195,11 +195,9 @@ You'll want to navigate to the `keyboard/<project_name>/` folder by typing, like
#### config.h #### 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). 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).
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).
#### \<project_name\>.h #### \<project_name\>.h

7
keyboard/Bantam44/config.h
Unescape Escape View File

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

7
keyboard/atomic/config.h
Unescape Escape 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) * 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 MATRIX_ROW_PINS { D0, D5, B5, B6, C6 }
#define ROWS (int []){ 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 */ /* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW #define DIODE_DIRECTION COL2ROW
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */ /* 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 if matrix has ghost (lacks anti-ghosting diodes) */
//#define MATRIX_HAS_GHOST //#define MATRIX_HAS_GHOST

7
keyboard/atomic/keymaps/pvc/config.h
Unescape Escape 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) * 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 MATRIX_ROW_PINS { D0, D5, B5, B6, B3 }
#define ROWS (int []){ 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 */ /* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW #define DIODE_DIRECTION COL2ROW
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */ /* 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 if matrix has ghost (lacks anti-ghosting diodes) */
//#define MATRIX_HAS_GHOST //#define MATRIX_HAS_GHOST

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

@ -62,8 +62,6 @@
#define M_BDFLT M(MACRO_BREATH_DEFAULT) #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_UP M(MACRO_INC_VOICE)
#define VC_DOWN M(MACRO_DEC_VOICE) #define VC_DOWN M(MACRO_DEC_VOICE)
@ -156,11 +154,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* UPPER /* UPPER
* .---------------------------------------------------------------------------------------------------------------------- 2u ------------. * .---------------------------------------------------------------------------------------------------------------------- 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 ------------+--------| * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+- 2u ------------+--------|
* | CAP LK | F5 | F6 | F7 | F8 | | | 4 | 5 | 6 | + | ` | XXXXXX . | HOME | * | CAP LK | F5 | F6 | F7 | F8 | | | 4 | 5 | 6 | + | | XXXXXX . | HOME |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+- 2u ---------------------+--------| * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+- 2u ---------------------+--------|
* | | F9 | F10 | F11 | F12 | | | 1 | 2 | 3 | ENTER | XXXXXX . | | END | * | | F9 | F10 | F11 | F12 | | | 1 | 2 | 3 | ENTER | XXXXXX . | | END |
* |--------+--------+--------+--------+--------+- 2u ------------+--------+--------+--------+--------+-----------------+--------+--------| * |--------+--------+--------+--------+--------+- 2u ------------+--------+--------+--------+--------+-----------------+--------+--------|
@ -498,31 +496,10 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
#ifdef AUDIO_ENABLE #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) void matrix_init_user(void)
{ {
set_voice(default_voice); set_voice(default_voice);
play_startup_tone(); startup_user();
println("Matrix Init"); 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 _delay_ms(10); // gets rid of tick
PLAY_NOTE_ARRAY(tone_my_startup, false, STACCATO); PLAY_NOTE_ARRAY(tone_my_startup, false, STACCATO);
} }
void play_goodbye_tone() void shutdown_user()
{ {
PLAY_NOTE_ARRAY(tone_my_goodbye, false, STACCATO); PLAY_NOTE_ARRAY(tone_my_goodbye, false, STACCATO);
_delay_ms(2000); _delay_ms(2000);
stop_all_notes(); stop_all_notes();
} }
void play_audio_on_tone(void) void audio_on_user(void)
{ {
PLAY_NOTE_ARRAY(tone_audio_on, false, STACCATO); 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); 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); PLAY_NOTE_ARRAY(music_scale, false, STACCATO);
} }

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

25
keyboard/clueboard1/config.h
Unescape Escape View File

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

19
keyboard/clueboard2/config.h
Unescape Escape View File

@ -32,19 +32,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define MATRIX_ROWS 10 #define MATRIX_ROWS 10
#define MATRIX_COLS 8 #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 /* Column pin configuration
* col: 0 1 2 3 4 5 6 7 * col: 0 1 2 3 4 5 6 7
* pin: F0 F1 F4 F5 F6 F7 E6 B1 * pin: F0 F1 F4 F5 F6 F7 E6 B1
*/ */
#define COLS (int []){ F0, F1, F4, F5, F6, F7, E6, B1 } #define MATRIX_COL_PINS { F0, F1, F4, F5, F6, F7, E6, B1 }
#define UNUSED_PINS
/* 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 }
/* COL2ROW or ROW2COL */ /* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW #define DIODE_DIRECTION COL2ROW
@ -53,7 +52,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
//#define MATRIX_HAS_GHOST //#define MATRIX_HAS_GHOST
/* Set 0 if debouncing isn't needed */ /* 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 */ /* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
#define LOCKING_SUPPORT_ENABLE #define LOCKING_SUPPORT_ENABLE

19
keyboard/cluepad/config.h
Unescape Escape View File

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

7
keyboard/gh60_rev_c/config.h
Unescape Escape 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) * 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 MATRIX_ROW_PINS { D0, D1, D2, D3, D5 }
#define ROWS (int []){ 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 */ /* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW #define DIODE_DIRECTION COL2ROW
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */ /* 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 if matrix has ghost (lacks anti-ghosting diodes) */
//#define MATRIX_HAS_GHOST //#define MATRIX_HAS_GHOST

7
keyboard/jd45/config.h
Unescape Escape View File

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

7
keyboard/planck/config.h
Unescape Escape View File

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

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

@ -174,21 +174,16 @@ const uint16_t PROGMEM fn_actions[] = {
}; };
#ifdef AUDIO_ENABLE #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_qwerty[][2] = SONG(QWERTY_SOUND);
float tone_dvorak[][2] = SONG(DVORAK_SOUND); float tone_dvorak[][2] = SONG(DVORAK_SOUND);
float tone_colemak[][2] = SONG(COLEMAK_SOUND); float tone_colemak[][2] = SONG(COLEMAK_SOUND);
float tone_plover[][2] = SONG(PLOVER_SOUND); float tone_plover[][2] = SONG(PLOVER_SOUND);
float tone_plover_gb[][2] = SONG(PLOVER_GOODBYE_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 #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) { void matrix_init_user(void) {
#ifdef AUDIO_ENABLE #ifdef AUDIO_ENABLE
_delay_ms(20); // stops the tick startup_user();
PLAY_NOTE_ARRAY(tone_startup, false, 0); #endif
#endif
} }
#ifdef AUDIO_ENABLE #ifdef AUDIO_ENABLE
void play_goodbye_tone()
void startup_user()
{
_delay_ms(20); // gets rid of tick
PLAY_NOTE_ARRAY(tone_startup, false, 0);
}
void shutdown_user()
{ {
PLAY_NOTE_ARRAY(goodbye, false, 0); PLAY_NOTE_ARRAY(tone_goodbye, false, 0);
_delay_ms(150); _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 #endif

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

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

291
keyboard/planck/keymaps/pvc/keymap.c
Unescape Escape View File

@ -8,43 +8,44 @@
#include "song_list.h" #include "song_list.h"
#endif #endif
#define LAYER_QWERTY 0 #define LAYER_QWERTY 0
#define LAYER_COLEMAK 1 #define LAYER_COLEMAK 1
#define LAYER_DVORAK 2 #define LAYER_DVORAK 2
#define LAYER_LOWER 3 #define LAYER_UPPER 3
#define LAYER_RAISE 4 #define LAYER_LOWER 4
#define LAYER_FUNCTION 5 #define LAYER_FUNCTION 5
#define LAYER_MOUSE 6 #define LAYER_MOUSE 6
#define LAYER_MUSIC 7 #define LAYER_ADJUST 7
#define LAYER_ADJUST 8
#define MACRO_QWERTY 0
#define MACRO_QWERTY 0 #define MACRO_COLEMAK 1
#define MACRO_COLEMAK 1 #define MACRO_DVORAK 2
#define MACRO_DVORAK 2 #define MACRO_UPPER 3
#define MACRO_LOWER 3 #define MACRO_LOWER 4
#define MACRO_RAISE 4 #define MACRO_FUNCTION 5
#define MACRO_FUNCTION 5 #define MACRO_MOUSE 6
#define MACRO_MOUSE 6 #define MACRO_TIMBRE_1 7
#define MACRO_TIMBRE_1 7 #define MACRO_TIMBRE_2 8
#define MACRO_TIMBRE_2 8 #define MACRO_TIMBRE_3 9
#define MACRO_TIMBRE_3 9 #define MACRO_TIMBRE_4 10
#define MACRO_TIMBRE_4 10 #define MACRO_TEMPO_U 11
#define MACRO_TEMPO_U 11 #define MACRO_TEMPO_D 12
#define MACRO_TEMPO_D 12 #define MACRO_TONE_DEFAULT 13
#define MACRO_TONE_DEFAULT 13 #define MACRO_MUSIC_TOGGLE 14
#define MACRO_MUSIC_ON 14 #define MACRO_AUDIO_TOGGLE 16
#define MACRO_MUSIC_OFF 15 #define MACRO_INC_VOICE 18
#define MACRO_AUDIO_ON 16 #define MACRO_DEC_VOICE 19
#define MACRO_AUDIO_OFF 17 #define MACRO_BACKLIGHT 20
#define MACRO_INC_VOICE 18 #define MACRO_BREATH_TOGGLE 21
#define MACRO_DEC_VOICE 19 #define MACRO_BREATH_SPEED_INC 23
#define MACRO_BACKLIGHT 20 #define MACRO_BREATH_SPEED_DEC 24
#define MACRO_BREATH_DEFAULT 25
#define M_QWRTY M(MACRO_QWERTY) #define M_QWRTY M(MACRO_QWERTY)
#define M_COLMK M(MACRO_COLEMAK) #define M_COLMK M(MACRO_COLEMAK)
#define M_DVORK M(MACRO_DVORAK) #define M_DVORK M(MACRO_DVORAK)
#define M_UPPER M(MACRO_UPPER)
#define M_LOWER M(MACRO_LOWER) #define M_LOWER M(MACRO_LOWER)
#define M_RAISE M(MACRO_RAISE)
#define M_FUNCT M(MACRO_FUNCTION) #define M_FUNCT M(MACRO_FUNCTION)
#define M_MOUSE M(MACRO_MOUSE) #define M_MOUSE M(MACRO_MOUSE)
#define TIMBR_1 M(MACRO_TIMBRE_1) #define TIMBR_1 M(MACRO_TIMBRE_1)
@ -55,12 +56,12 @@
#define TMPO_DN M(MACRO_TEMPO_D) #define TMPO_DN M(MACRO_TEMPO_D)
#define TMPO_DF M(MACRO_TONE_DEFAULT) #define TMPO_DF M(MACRO_TONE_DEFAULT)
#define M_BACKL M(MACRO_BACKLIGHT) #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_UP M(MACRO_INC_VOICE)
#define VC_DOWN M(MACRO_DEC_VOICE) #define VC_DOWN M(MACRO_DEC_VOICE)
@ -76,6 +77,7 @@
#define SC_ACLS LALT(KC_F4) #define SC_ACLS LALT(KC_F4)
#define SC_CCLS LCTL(KC_F4) #define SC_CCLS LCTL(KC_F4)
#define OS_SHFT KC_FN0
#define _______ KC_TRNS #define _______ KC_TRNS
#define XXXXXXX KC_NO #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 | ; | ' | * | 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 */ [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_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_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_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_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, OS_SHFT, KC_LEFT, KC_DOWN, KC_RGHT },
}, },
/* COLEMAK /* 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 | ' | * | 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_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_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_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_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, OS_SHFT, KC_LEFT, KC_DOWN, KC_RGHT },
}, },
/* DVORAK /* DVORAK
* .-----------------------------------------------------------------------------------------------------------. * .-----------------------------------------------------------------------------------------------------------.
* | TAB | ' | , | . | P | Y | F | G | C | R | L | BACKSP | * | 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 | * | 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_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_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_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 | * | | F9 | F10 | F11 | F12 | PAUSE | | 1 | 2 | 3 | ENTER | HOME |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
* | LCTRL | LWIN | FN | LALT | RAISE | BACKSP | BACKSP | LOWER | PG UP | PG DN | HOME | END | * | | | | | | 0 | 0 | | RALT | . | ENTER | END |
* '-----------------------------------------------------------------------------------------------------------' * '-----------------------------------------------------------------------------------------------------------'
*/ */
[LAYER_RAISE] = { /* RAISED */ [LAYER_UPPER] = { // UPPER
{ KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL }, { 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 },
{ XXXXXXX, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS }, { 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_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX }, { _______, 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_BSPC, KC_BSPC, _______, KC_PGUP, KC_PGDN, KC_HOME, KC_END }, { _______, _______, _______, _______, _______, KC_KP_0, KC_KP_0, _______, KC_RALT, KC_PDOT, KC_PENT, KC_END },
}, },
/* LOWER
/* LOWERED
* .-----------------------------------------------------------------------------------------------------------. * .-----------------------------------------------------------------------------------------------------------.
* | ~ | ! | @ | # | $ | % | ^ | & | * | ( | ) | INS | * | | $ | { | [ | ( | % | # | ) | ] | } | @ | PG UP |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | XXXXXX | F1 | F2 | F3 | F4 | F5 | F6 | _ | + | { | } | | | * | | ^ | * | + | - | ; | : | _ | ' | " | ` | PG DN |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | LSHIFT | F7 | F8 | F9 | F10 | F11 | F12 | XXXXXX | XXXXXX | XXXXXX | XXXXXX | ENTER | * | | | | & | ! | ~ | / | \ | = | < | > | ? | HOME |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------| * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
* | LCTRL | LWIN | FN | LALT | RAISE | BACKSP | BACKSP | LOWER | PG UP | PG DN | HOME | END | * | | | | | | | | | | | | END |
* '-----------------------------------------------------------------------------------------------------------' * '-----------------------------------------------------------------------------------------------------------'
*/ */
[LAYER_LOWER] = { /* LOWERED */ [LAYER_LOWER] = { // LOWER
{ KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_INS }, { _______, KC_DLR, KC_LCBR, KC_LBRC, KC_LPRN, KC_PERC, KC_HASH, KC_RPRN, KC_RBRC, KC_RCBR, KC_AT, KC_PGUP },
{ XXXXXXX, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS }, { _______, KC_CIRC, KC_ASTR, KC_PPLS, KC_PMNS, KC_SCLN, KC_COLN, KC_UNDS, KC_QUOT, KC_DQT, KC_GRV, KC_PGDN },
{ _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX }, { _______, KC_PIPE, KC_AMPR, KC_EXLM, KC_TILD, KC_SLSH, KC_BSLS, KC_EQL, KC_LT, KC_GT, KC_QUES, KC_HOME },
{ _______, _______, _______, _______, _______, KC_BSPC, KC_BSPC, _______, KC_PGUP, KC_PGDN, KC_HOME, KC_END }, { _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_END },
}, },
/* FUNCTION /* FUNCTION
* .-----------------------------------------------------------------------------------------------------------. * .-----------------------------------------------------------------------------------------------------------.
* | NUM LK | F1 | F2 | F3 | F4 | F5 | F6 | F7 | F8 | F9 | F10 | PAUSE | * | 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 | * | 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_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_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 }, { 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 #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 }, { 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 }, { 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 }, { _______, 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 #endif
[LAYER_MUSIC] = { /* MUSIC */ [LAYER_ADJUST] = { // ADJUST
{ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX }, { _______, TIMBR_1, TIMBR_2, TIMBR_3, TIMBR_4, TMPO_UP, TMPO_DN, TMPO_DF, _______, _______, MU_TOG, AU_TOG },
{ 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 },
{ _______, M_QWRTY, M_COLMK, M_DVORK, _______, _______, _______, _______, _______, _______, _______, _______ }, { _______, M_QWRTY, M_COLMK, M_DVORK, _______, _______, _______, _______, _______, _______, _______, _______ },
{ _______, _______, _______, _______, M_BACKL, RESET, _______, M_MOUSE, _______, _______, _______, _______ }, { _______, _______, _______, _______, M_BACKL, RESET, _______, M_MOUSE, _______, _______, MUV_IN, _______ },
{ _______, _______, _______, _______, _______, _______, _______, _______, VC_UP, VC_DOWN, _______, _______ }, { _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, MUV_DE, _______ },
}, },
/* /*
[LAYER_EMPTY] = { [LAYER_EMPTY] = {
{ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, }, { _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, },
@ -263,6 +257,7 @@ void persistant_default_layer_set(uint16_t default_layer)
} }
const uint16_t PROGMEM fn_actions[] = { 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) 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) if (record->event.pressed)
{ {
layer_on(LAYER_LOWER); layer_on(LAYER_LOWER);
update_tri_layer(LAYER_LOWER, LAYER_RAISE, LAYER_ADJUST); update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
} }
else else
{ {
layer_off(LAYER_LOWER); layer_off(LAYER_LOWER);
update_tri_layer(LAYER_LOWER, LAYER_RAISE, LAYER_ADJUST); update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
} }
break; break;
case MACRO_RAISE: case MACRO_UPPER:
if (record->event.pressed) if (record->event.pressed)
{ {
layer_on(LAYER_RAISE); layer_on(LAYER_UPPER);
update_tri_layer(LAYER_LOWER, LAYER_RAISE, LAYER_ADJUST); update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
} }
else else
{ {
layer_off(LAYER_RAISE); layer_off(LAYER_UPPER);
update_tri_layer(LAYER_LOWER, LAYER_RAISE, LAYER_ADJUST); update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
} }
break; break;
@ -393,65 +388,6 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
} }
break; 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 */ #endif /* AUDIO_ENABLE */
default: default:
@ -464,31 +400,10 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
#ifdef AUDIO_ENABLE #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) void matrix_init_user(void)
{ {
set_voice(default_voice); set_voice(default_voice);
play_startup_tone(); startup_user();
println("Matrix Init"); 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 _delay_ms(10); // gets rid of tick
PLAY_NOTE_ARRAY(tone_my_startup, false, STACCATO); PLAY_NOTE_ARRAY(tone_my_startup, false, STACCATO);
} }
void play_goodbye_tone() void shutdown_user()
{ {
PLAY_NOTE_ARRAY(tone_my_goodbye, false, STACCATO); 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 */ #endif /* AUDIO_ENABLE */

7
keyboard/preonic/config.h
Unescape Escape View File

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

7
keyboard/retro_refit/config.h
Unescape Escape View File

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

17
quantum/audio/audio.c
Unescape Escape View File

@ -475,20 +475,3 @@ void increase_tempo(uint8_t tempo_change) {
note_tempo -= 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
Unescape Escape View File

@ -5,6 +5,7 @@
#include "musical_notes.h" #include "musical_notes.h"
#include "song_list.h" #include "song_list.h"
#include "voices.h" #include "voices.h"
#include "quantum.h"
#ifndef AUDIO_H #ifndef AUDIO_H
#define 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); 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 #endif

125
quantum/config_common.h
Unescape Escape View File

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

3
quantum/keymap_common.c
Unescape Escape View File

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

361
quantum/matrix.c
Unescape Escape View File

@ -1,6 +1,6 @@
/* /*
Copyright 2012 Jun Wako 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 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 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 You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
/*
* scan matrix
*/
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <avr/io.h> #include <avr/io.h>
#include <util/delay.h> #include "wait.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "util.h" #include "util.h"
#include "matrix.h" #include "matrix.h"
#ifndef DEBOUNCE #ifdef MATRIX_HAS_GHOST
# define DEBOUNCE 10 # error "The universal matrix.c file cannot be used for this keyboard."
#endif #endif
static uint8_t debouncing = DEBOUNCE;
/* matrix state(1:on, 0:off) */ #ifndef DEBOUNCING_DELAY
static matrix_row_t matrix[MATRIX_ROWS]; # define DEBOUNCING_DELAY 5
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 #endif
static const io_pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
#if MATRIX_COLS > 16 static const io_pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
#define SHIFTER 1UL /* matrix state */
#if DIODE_DIRECTION == COL2ROW
static matrix_row_t matrix[MATRIX_ROWS];
#else #else
#define SHIFTER 1 static matrix_col_t matrix[MATRIX_COLS];
#endif #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 matrix_row_t read_cols(void);
static void init_cols(void); #else
static void unselect_rows(void); static void toggle_col(uint8_t col);
static void select_row(uint8_t row); static matrix_col_t read_rows(void);
#endif
__attribute__ ((weak)) __attribute__ ((weak))
void matrix_init_quantum(void) { void matrix_init_quantum(void) {
} }
__attribute__ ((weak)) __attribute__ ((weak))
void matrix_scan_quantum(void) { void matrix_scan_quantum(void) {
} }
inline uint8_t matrix_rows(void) {
uint8_t matrix_rows(void)
{
return MATRIX_ROWS; return MATRIX_ROWS;
} }
inline uint8_t matrix_cols(void) {
uint8_t matrix_cols(void)
{
return MATRIX_COLS; return MATRIX_COLS;
} }
void matrix_init(void) void matrix_init(void) {
{ /* frees PORTF by setting the JTD bit twice within four cycles */
// To use PORTF disable JTAG with writing JTD bit twice within four cycles. MCUCR |= _BV(JTD);
MCUCR |= (1<<JTD); MCUCR |= _BV(JTD);
MCUCR |= (1<<JTD); /* initializes the I/O pins */
#if DIODE_DIRECTION == COL2ROW
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
// initialize row and col /* DDRxn */
unselect_rows(); _SFR_IO8(row_pins[r].input_addr + 1) |= _BV(row_pins[r].bit);
init_cols(); toggle_row(r);
// initialize matrix state: all keys off
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
matrix[i] = 0;
matrix_debouncing[i] = 0;
} }
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(); matrix_init_quantum();
} }
uint8_t matrix_scan(void)
{
#if DIODE_DIRECTION == COL2ROW #if DIODE_DIRECTION == COL2ROW
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { uint8_t matrix_scan(void) {
select_row(i); static matrix_row_t debouncing_matrix[MATRIX_ROWS];
_delay_us(30); // without this wait read unstable value. for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
matrix_row_t cols = read_cols(); toggle_row(r);
if (matrix_debouncing[i] != cols) { matrix_row_t state = read_cols();
matrix_debouncing[i] = cols; if (debouncing_matrix[r] != state) {
if (debouncing) { debouncing_matrix[r] = state;
debug("bounce!: "); debug_hex(debouncing); debug("\n"); debouncing_delay = DEBOUNCING_DELAY;
}
debouncing = DEBOUNCE;
} }
unselect_rows(); toggle_row(r);
} }
if (debouncing_delay >= 0) {
if (debouncing) { dprintf("Debouncing delay remaining: %X\n", debouncing_delay);
if (--debouncing) { --debouncing_delay;
_delay_ms(1); if (debouncing_delay >= 0) {
} else { wait_ms(1);
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i];
}
} }
} else {
#else for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
for (uint8_t i = 0; i < MATRIX_COLS; i++) { matrix[r] = debouncing_matrix[r];
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(); matrix_scan_quantum();
return 1; return 1;
} }
bool matrix_is_modified(void) static void toggle_row(uint8_t row) {
{ /* PINxn */
if (debouncing) return false; _SFR_IO8(row_pins[row].input_addr) = _BV(row_pins[row].bit);
return true;
} }
inline static matrix_row_t read_cols(void) {
bool matrix_is_on(uint8_t row, uint8_t col) matrix_row_t state = 0;
{ for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
return (matrix[row] & ((matrix_row_t)1<col)); /* 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]; return matrix[row];
} }
void matrix_print(void) #else
{ uint8_t matrix_scan(void) {
print("\nr/c 0123456789ABCDEF\n"); static matrix_col_t debouncing_matrix[MATRIX_COLS];
for (uint8_t row = 0; row < MATRIX_ROWS; row++) { for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
phex(row); print(": "); toggle_col(c);
pbin_reverse16(matrix_get_row(row)); matrix_col_t state = read_rows();
print("\n"); 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);
uint8_t matrix_key_count(void) --debouncing_delay;
{ if (debouncing_delay >= 0) {
uint8_t count = 0; wait_ms(1);
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { }
count += bitpop16(matrix[i]); else {
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
matrix[c] = debouncing_matrix[c];
}
}
} }
return count; matrix_scan_quantum();
return 1;
} }
static void init_cols(void) static void toggle_col(uint8_t col) {
{ /* PINxn */
int B = 0, C = 0, D = 0, E = 0, F = 0; _SFR_IO8(col_pins[col].input_addr) = _BV(col_pins[col].bit);
}
#if DIODE_DIRECTION == COL2ROW static matrix_col_t read_rows(void) {
for(int x = 0; x < MATRIX_COLS; x++) { matrix_col_t state = 0;
int col = COLS[x]; for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
#else /* PINxn */
for(int x = 0; x < MATRIX_ROWS; x++) { if (!(_SFR_IO8(row_pins[r].input_addr) & _BV(row_pins[r].bit))) {
int col = ROWS[x]; state |= (matrix_col_t)1 << r;
#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); return state;
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 matrix_get_row(uint8_t row) {
{ matrix_row_t state = 0;
matrix_row_t result = 0; matrix_col_t mask = (matrix_col_t)1 << row;
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
#if DIODE_DIRECTION == COL2ROW if (matrix[c] & mask) {
for(int x = 0; x < MATRIX_COLS; x++) { state |= (matrix_row_t)1 << c;
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; return state;
} }
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 #endif
if ((row & 0xF0) == 0x20) {
B |= (1<<(row & 0x0F)); bool matrix_is_modified(void) {
} else if ((row & 0xF0) == 0x30) { if (debouncing_delay >= 0) return false;
C |= (1<<(row & 0x0F)); return true;
} 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) bool matrix_is_on(uint8_t row, uint8_t col) {
{ return matrix_get_row(row) & (matrix_row_t)1 << col;
}
#if DIODE_DIRECTION == COL2ROW void matrix_print(void) {
int row_pin = ROWS[row]; dprintln("Human-readable matrix state:");
#else for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
int row_pin = COLS[row]; dprintf("State of row %X: %016b\n", r, bitrev16(matrix_get_row(r)));
#endif }
}
if ((row_pin & 0xF0) == 0x20) { uint8_t matrix_key_count(void) {
DDRB |= (1<<(row_pin & 0x0F)); uint8_t count = 0;
PORTB &= ~(1<<(row_pin & 0x0F)); for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
} else if ((row_pin & 0xF0) == 0x30) { count += bitpop16(matrix_get_row(r));
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));
} }
return count;
} }

69
quantum/quantum.c
Unescape Escape View File

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

4
quantum/quantum.h
Unescape Escape View File

@ -67,6 +67,10 @@ void music_toggle(void);
void music_on(void); void music_on(void);
void music_off(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_on_user(void);
void music_scale_user(void);
#endif #endif

7
quantum/template/config.h
Unescape Escape 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) * ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
* *
*/ */
#define COLS (int []){ F1, F0, B0 } #define MATRIX_ROW_PINS { D0, D5 }
#define ROWS (int []){ D0, D5 } #define MATRIX_COL_PINS { F1, F0, B0 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */ /* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW #define DIODE_DIRECTION COL2ROW
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */ /* 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 if matrix has ghost (lacks anti-ghosting diodes) */
//#define MATRIX_HAS_GHOST //#define MATRIX_HAS_GHOST

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

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

14
tmk_core/common/bootmagic.c
Unescape Escape View File

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

13
tmk_core/common/command.c
Unescape Escape View File

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

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

61
tmk_core/common/matrix.h
Unescape Escape 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 You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef MATRIX_H #ifndef MATRIX_H
#define MATRIX_H #define MATRIX_H
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#if MATRIX_COLS <= 8
#if (MATRIX_COLS <= 8) typedef uint8_t matrix_row_t;
typedef uint8_t matrix_row_t; #elif MATRIX_COLS <= 16
#elif (MATRIX_COLS <= 16) typedef uint16_t matrix_row_t;
typedef uint16_t matrix_row_t; #elif MATRIX_COLS <= 32
#elif (MATRIX_COLS <= 32) typedef uint32_t matrix_row_t;
typedef uint32_t matrix_row_t;
#else #else
#error "MATRIX_COLS: invalid value" # error "There are too many columns."
#endif #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 #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* counts the number of rows in the matrix */
/* number of matrix rows */
uint8_t matrix_rows(void); uint8_t matrix_rows(void);
/* number of matrix columns */ /* counts the number of columns in the matrix */
uint8_t matrix_cols(void); 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); void matrix_setup(void);
/* intialize matrix for scaning. */ /* intializes the matrix */
void matrix_init(void); void matrix_init(void);
/* scan all key states on matrix */ /* scans the entire matrix */
uint8_t matrix_scan(void); 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)); 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); 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); matrix_row_t matrix_get_row(uint8_t row);
/* print matrix for debug */ /* prints the matrix for debugging */
void matrix_print(void); void matrix_print(void);
/* counts the total number of keys pressed */
uint8_t matrix_key_count(void);
/* power control */ /* controls power to the matrix */
void matrix_power_up(void); void matrix_power_up(void);
void matrix_power_down(void); void matrix_power_down(void);
/* executes code for Quantum */
/* keyboard-specific setup/loop functionality */
void matrix_init_quantum(void); void matrix_init_quantum(void);
void matrix_scan_quantum(void); void matrix_scan_quantum(void);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

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

@ -947,10 +947,10 @@ void fallthrough_callback(MidiDevice * device,
if (cnt == 3) { if (cnt == 3) {
switch (byte0 & 0xF0) { switch (byte0 & 0xF0) {
case MIDI_NOTEON: 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; break;
case MIDI_NOTEOFF: 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; break;
} }
} }

8
tmk_core/rules.mk
Unescape Escape View File

@ -366,7 +366,13 @@ ALL_ASFLAGS = -mmcu=$(MCU) -x assembler-with-cpp $(ASFLAGS) $(EXTRAFLAGS)
# Default target. # 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. # Change the build target to build a HEX file or a library.
build: elf hex eep lss sym build: elf hex eep lss sym

Write Preview
Loading…
Cancel
Save