yohan/qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Actions Packages 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

26
HAND_WIRE.md
View File

@ -51,11 +51,11 @@ A problem arises when you start pressing more than one key at a time. Looking at
x row0 ---(-+-0)---(-+-1) x row0 ---(-+-0)---(-+-1) x row0 ---(-+-0)---(-+-1) x row0 ---(-+-0)---(-+-1)
| | | | | | | |
x row1 ---(key2)---(-+-3) x row1 ---(key2)---(-+-3) x row1 ---(key2)---(-+-3) x row1 ---(key2)---(-+-3)
Remember that this ^ is still connected to row1 Remember that this ^ is still connected to row1
The data we get from that is: The data we get from that is:
col0: 0b11 col0: 0b11
col1: 0b11 col1: 0b11
│└row0 │└row0
@ -73,7 +73,7 @@ Which isn't accurate, since we only have 3 keys pressed down, not all 4. This be
│ │ | │ │ │ | │
(key2) (key3) (key2) (key3) (key2) (key3) (key2) (key3)
! ! ! ! ! ! ! !
row1 ─────┴────────┘ row1 ─────┴────────┘ row1 ─────┴────────┘ row1 ─────┴────────┘
In practical applications, the black line of the diode will be placed facing the row, and away from the keyswitch - the `!` in this case is the diode, where the gap represents the black line. A good way to remember this is to think of this symbol: `>|` In practical applications, the black line of the diode will be placed facing the row, and away from the keyswitch - the `!` in this case is the diode, where the gap represents the black line. A good way to remember this is to think of this symbol: `>|`
@ -89,10 +89,10 @@ Now when we press the three keys, invoking what would be a ghosting scenario:
│ │ │ │ │ │ │ │
(key2) (┌─┘3) (key2) (┌─┘3) (key2) (┌─┘3) (key2) (┌─┘3)
! ! ! ! ! ! ! !
row1 ─────┴────────┘ x row1 ─────┴────────┘ row1 ─────┴────────┘ x row1 ─────┴────────┘
Things act as they should! Which will get us the following data: Things act as they should! Which will get us the following data:
col0: 0b01 col0: 0b01
col1: 0b11 col1: 0b11
│└row0 │└row0
@ -106,7 +106,7 @@ The firmware can then use this correct data to detect what it should do, and eve
When starting this, you should have all of your stabilisers and keyswitches already installed (and optionally keycaps). If you're using a Cherry-type stabiliser (plate-mounted only, obviously), you'll need to install that before your keyswitches. If you're using Costar ones, you can installed them afterwards. When starting this, you should have all of your stabilisers and keyswitches already installed (and optionally keycaps). If you're using a Cherry-type stabiliser (plate-mounted only, obviously), you'll need to install that before your keyswitches. If you're using Costar ones, you can installed them afterwards.
To make things easier on yourself, make sure all of the keyswitches are oriented the same way (if they can be - not all layouts support this). Despite this, it's important to remember that the contacts on the keyswitches are completely symmetrical. We'll be using the keyswitch's left side contact for wiring the rows, and the right side one for wiring the columns. To make things easier on yourself, make sure all of the keyswitches are oriented the same way (if they can be - not all layouts support this). Despite this, it's important to remember that the contacts on the keyswitches are completely symmetrical. We'll be using the keyswitch's left side contact for wiring the rows, and the right side one for wiring the columns.
Get your soldering iron heated-up and collect the rest of the materials from the part list at the beginning of the guide. Place your keyboard so that the bottoms of the keyswitches are accessible - it may be a good idea to place it on a cloth to protect your keyswitches/keycaps. Get your soldering iron heated-up and collect the rest of the materials from the part list at the beginning of the guide. Place your keyboard so that the bottoms of the keyswitches are accessible - it may be a good idea to place it on a cloth to protect your keyswitches/keycaps.
@ -155,7 +155,7 @@ When all of the diodes are completely soldered, it's a good idea to quickly insp
### Soldering the columns ### Soldering the columns
You'll have some options in the next process - it's a good idea to insulate the column wires (since the diodes aren't), but if you're careful enough, you can use exposed wires for the columns - it's not recommended, though. If you're using single-cored wire, stripping the plastic off of the whole wire and feeding it back on is probably the best option, but can be difficult depending on the size and materials. You'll want to leave parts of the wire exposed where you're going to be solder it onto the keyswitch. You'll have some options in the next process - it's a good idea to insulate the column wires (since the diodes aren't), but if you're careful enough, you can use exposed wires for the columns - it's not recommended, though. If you're using single-cored wire, stripping the plastic off of the whole wire and feeding it back on is probably the best option, but can be difficult depending on the size and materials. You'll want to leave parts of the wire exposed where you're going to be solder it onto the keyswitch.
If you're using stranded wire, it's probably easiest to just use a lot of small wires to connect each keyswitch along the column. It's possible to use one and melt through the insulation, but this isn't recommended, will produce even more harmful fumes, and can ruin your soldering iron. If you're using stranded wire, it's probably easiest to just use a lot of small wires to connect each keyswitch along the column. It's possible to use one and melt through the insulation, but this isn't recommended, will produce even more harmful fumes, and can ruin your soldering iron.
@ -195,15 +195,13 @@ 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
The next file you'll want to look at is `<project_name>.h`. You're going to want to rewrite the `KEYMAP` definition - the format and syntax here is extremely important, so pay attention to how things are setup. The first half of the definition are considered the arguments - this is the format that you'll be following in your keymap later on, so you'll want to have as many k*xy* variables here as you do keys. The second half is the part that the firmware actually looks at, and will contain gaps depending on how you wired your matrix. The next file you'll want to look at is `<project_name>.h`. You're going to want to rewrite the `KEYMAP` definition - the format and syntax here is extremely important, so pay attention to how things are setup. The first half of the definition are considered the arguments - this is the format that you'll be following in your keymap later on, so you'll want to have as many k*xy* variables here as you do keys. The second half is the part that the firmware actually looks at, and will contain gaps depending on how you wired your matrix.
We'll dive into how this will work with the following example. Say we have a keyboard like this: We'll dive into how this will work with the following example. Say we have a keyboard like this:
@ -230,7 +228,7 @@ The middle column is unused on the bottom row in this example. Our `KEYMAP` defi
{ \ { \
{ k00, k01, k02 }, \ { k00, k01, k02 }, \
{ k10, KC_NO, k11 }, \ { k10, KC_NO, k11 }, \
} }
Notice how the top half is spaced to resemble our physical layout - this helps us understand which keys are associated with which columns. The bottom half uses the keycode `KC_NO` where there is no keyswitch wired in. It's easiest to keep the bottom half aligned in a grid to help us make sense of how the firmware actually sees the wiring. Notice how the top half is spaced to resemble our physical layout - this helps us understand which keys are associated with which columns. The bottom half uses the keycode `KC_NO` where there is no keyswitch wired in. It's easiest to keep the bottom half aligned in a grid to help us make sense of how the firmware actually sees the wiring.
@ -251,7 +249,7 @@ This would require our `KEYMAP` definition to look like this:
{ \ { \
{ k00, k01, k02 }, \ { k00, k01, k02 }, \
{ k10, k11, KC_NO }, \ { k10, k11, KC_NO }, \
} }
Notice how the `k11` and `KC_NO` switched places to represent the wiring, and the unused final column on the bottom row. Sometimes it'll make more sense to put a keyswitch on a particular column, but in the end, it won't matter, as long as all of them are accounted for. You can use this process to write out the `KEYMAP` for your entire keyboard - be sure to remember that your keyboard is actually backwards when looking at the underside of it. Notice how the `k11` and `KC_NO` switched places to represent the wiring, and the unused final column on the bottom row. Sometimes it'll make more sense to put a keyswitch on a particular column, but in the end, it won't matter, as long as all of them are accounted for. You can use this process to write out the `KEYMAP` for your entire keyboard - be sure to remember that your keyboard is actually backwards when looking at the underside of it.

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 // 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

17
keyboard/atomic/config.h
View File

@ -41,15 +41,16 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
* DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode) * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
* 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
@ -62,17 +63,17 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* Locking resynchronize hack */ /* Locking resynchronize hack */
#define LOCKING_RESYNC_ENABLE #define LOCKING_RESYNC_ENABLE
/* /*
* Force NKRO * Force NKRO
* *
* Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
* state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
* makefile for this to work.) * makefile for this to work.)
* *
* If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N) * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
* until the next keyboard reset. * until the next keyboard reset.
* *
* NKRO may prevent your keystrokes from being detected in the BIOS, but it is * NKRO may prevent your keystrokes from being detected in the BIOS, but it is
* fully operational during normal computer usage. * fully operational during normal computer usage.
* *
* For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N) * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
@ -90,7 +91,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
* the keyboard. They are best used in combination with the HID Listen program, * the keyboard. They are best used in combination with the HID Listen program,
* found here: https://www.pjrc.com/teensy/hid_listen.html * found here: https://www.pjrc.com/teensy/hid_listen.html
* *
* The options below allow the magic key functionality to be changed. This is * The options below allow the magic key functionality to be changed. This is
* useful if your keyboard/keypad is missing keys and you want magic key support. * useful if your keyboard/keypad is missing keys and you want magic key support.
* *
*/ */

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) * 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
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
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
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
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
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

17
keyboard/gh60_rev_c/config.h
View File

@ -41,15 +41,16 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
* DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode) * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
* 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
@ -62,17 +63,17 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* Locking resynchronize hack */ /* Locking resynchronize hack */
#define LOCKING_RESYNC_ENABLE #define LOCKING_RESYNC_ENABLE
/* /*
* Force NKRO * Force NKRO
* *
* Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
* state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
* makefile for this to work.) * makefile for this to work.)
* *
* If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N) * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
* until the next keyboard reset. * until the next keyboard reset.
* *
* NKRO may prevent your keystrokes from being detected in the BIOS, but it is * NKRO may prevent your keystrokes from being detected in the BIOS, but it is
* fully operational during normal computer usage. * fully operational during normal computer usage.
* *
* For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N) * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
@ -90,7 +91,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
* the keyboard. They are best used in combination with the HID Listen program, * the keyboard. They are best used in combination with the HID Listen program,
* found here: https://www.pjrc.com/teensy/hid_listen.html * found here: https://www.pjrc.com/teensy/hid_listen.html
* *
* The options below allow the magic key functionality to be changed. This is * The options below allow the magic key functionality to be changed. This is
* useful if your keyboard/keypad is missing keys and you want magic key support. * useful if your keyboard/keypad is missing keys and you want magic key support.
* *
*/ */

9
keyboard/jd45/config.h
View File

@ -30,11 +30,12 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key matrix size */ /* key matrix size */
#define MATRIX_ROWS 4 #define MATRIX_ROWS 4
#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
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
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()
{ {
PLAY_NOTE_ARRAY(goodbye, false, 0); _delay_ms(20); // gets rid of tick
_delay_ms(150); 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 #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 #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

289
keyboard/planck/keymaps/pvc/keymap.c
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_LOWER 3 #define MACRO_UPPER 3
#define MACRO_RAISE 4 #define MACRO_LOWER 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_ON 14 #define MACRO_MUSIC_TOGGLE 14
#define MACRO_MUSIC_OFF 15 #define MACRO_AUDIO_TOGGLE 16
#define MACRO_AUDIO_ON 16 #define MACRO_INC_VOICE 18
#define MACRO_AUDIO_OFF 17 #define MACRO_DEC_VOICE 19
#define MACRO_INC_VOICE 18 #define MACRO_BACKLIGHT 20
#define MACRO_DEC_VOICE 19 #define MACRO_BREATH_TOGGLE 21
#define MACRO_BACKLIGHT 20 #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_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
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

9
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 #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
@ -119,4 +120,4 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
//#define NO_ACTION_MACRO //#define NO_ACTION_MACRO
//#define NO_ACTION_FUNCTION //#define NO_ACTION_FUNCTION
#endif #endif

17
quantum/audio/audio.c
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
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
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
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

393
quantum/matrix.c
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
# 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[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 #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 {
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(); 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);
--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; uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
count += bitpop16(matrix[i]); count += bitpop16(matrix_get_row(r));
} }
return count; 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 #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
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

17
quantum/template/config.h
View File

@ -41,15 +41,16 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
* DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode) * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
* 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
@ -62,17 +63,17 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* Locking resynchronize hack */ /* Locking resynchronize hack */
#define LOCKING_RESYNC_ENABLE #define LOCKING_RESYNC_ENABLE
/* /*
* Force NKRO * Force NKRO
* *
* Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
* state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
* makefile for this to work.) * makefile for this to work.)
* *
* If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N) * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
* until the next keyboard reset. * until the next keyboard reset.
* *
* NKRO may prevent your keystrokes from being detected in the BIOS, but it is * NKRO may prevent your keystrokes from being detected in the BIOS, but it is
* fully operational during normal computer usage. * fully operational during normal computer usage.
* *
* For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N) * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
@ -90,7 +91,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
* the keyboard. They are best used in combination with the HID Listen program, * the keyboard. They are best used in combination with the HID Listen program,
* found here: https://www.pjrc.com/teensy/hid_listen.html * found here: https://www.pjrc.com/teensy/hid_listen.html
* *
* The options below allow the magic key functionality to be changed. This is * The options below allow the magic key functionality to be changed. This is
* useful if your keyboard/keypad is missing keys and you want magic key support. * useful if your keyboard/keypad is missing keys and you want magic key support.
* *
*/ */

5
tmk_core/common/avr/suspend.c
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
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
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

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 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"
#ifdef BOOTMAGIC_ENABLE
#include "bootmagic.h"
#else
#include "magic.h"
#endif
#include "eeconfig.h" #include "eeconfig.h"
#include "backlight.h" #include "backlight.h"
#ifdef BOOTMAGIC_ENABLE
# include "bootmagic.h"
#else
# include "magic.h"
#endif
#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
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
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
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