b6_b7_audio
Jack Humbert
10 years ago
parent
b3f638f491
commit
f7bca5c41a
@ -0,0 +1,53 @@ |
||||
// Simple analog to digitial conversion
|
||||
|
||||
#include <avr/io.h> |
||||
#include <avr/pgmspace.h> |
||||
#include <stdint.h> |
||||
#include "analog.h" |
||||
|
||||
|
||||
static uint8_t aref = (1<<REFS0); // default to AREF = Vcc
|
||||
|
||||
|
||||
void analogReference(uint8_t mode) |
||||
{ |
||||
aref = mode & 0xC0; |
||||
} |
||||
|
||||
|
||||
// Arduino compatible pin input
|
||||
int16_t analogRead(uint8_t pin) |
||||
{ |
||||
#if defined(__AVR_ATmega32U4__) |
||||
static const uint8_t PROGMEM pin_to_mux[] = { |
||||
0x00, 0x01, 0x04, 0x05, 0x06, 0x07, |
||||
0x25, 0x24, 0x23, 0x22, 0x21, 0x20}; |
||||
if (pin >= 12) return 0; |
||||
return adc_read(pgm_read_byte(pin_to_mux + pin)); |
||||
#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__) |
||||
if (pin >= 8) return 0; |
||||
return adc_read(pin); |
||||
#else |
||||
return 0; |
||||
#endif |
||||
} |
||||
|
||||
// Mux input
|
||||
int16_t adc_read(uint8_t mux) |
||||
{ |
||||
#if defined(__AVR_AT90USB162__) |
||||
return 0; |
||||
#else |
||||
uint8_t low; |
||||
|
||||
ADCSRA = (1<<ADEN) | ADC_PRESCALER; // enable ADC
|
||||
ADCSRB = (1<<ADHSM) | (mux & 0x20); // high speed mode
|
||||
ADMUX = aref | (mux & 0x1F); // configure mux input
|
||||
ADCSRA = (1<<ADEN) | ADC_PRESCALER | (1<<ADSC); // start the conversion
|
||||
while (ADCSRA & (1<<ADSC)) ; // wait for result
|
||||
low = ADCL; // must read LSB first
|
||||
return (ADCH << 8) | low; // must read MSB only once!
|
||||
#endif |
||||
} |
||||
|
||||
|
||||
@ -0,0 +1,36 @@ |
||||
#ifndef _analog_h_included__ |
||||
#define _analog_h_included__ |
||||
|
||||
#include <stdint.h> |
||||
|
||||
void analogReference(uint8_t mode); |
||||
int16_t analogRead(uint8_t pin); |
||||
int16_t adc_read(uint8_t mux); |
||||
|
||||
#define ADC_REF_POWER (1<<REFS0) |
||||
#define ADC_REF_INTERNAL ((1<<REFS1) | (1<<REFS0)) |
||||
#define ADC_REF_EXTERNAL (0) |
||||
|
||||
// These prescaler values are for high speed mode, ADHSM = 1
|
||||
#if F_CPU == 16000000L |
||||
#define ADC_PRESCALER ((1<<ADPS2) | (1<<ADPS1)) |
||||
#elif F_CPU == 8000000L |
||||
#define ADC_PRESCALER ((1<<ADPS2) | (1<<ADPS0)) |
||||
#elif F_CPU == 4000000L |
||||
#define ADC_PRESCALER ((1<<ADPS2)) |
||||
#elif F_CPU == 2000000L |
||||
#define ADC_PRESCALER ((1<<ADPS1) | (1<<ADPS0)) |
||||
#elif F_CPU == 1000000L |
||||
#define ADC_PRESCALER ((1<<ADPS1)) |
||||
#else |
||||
#define ADC_PRESCALER ((1<<ADPS0)) |
||||
#endif |
||||
|
||||
// some avr-libc versions do not properly define ADHSM
|
||||
#if defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__) |
||||
#if !defined(ADHSM) |
||||
#define ADHSM (7) |
||||
#endif |
||||
#endif |
||||
|
||||
#endif |
||||
@ -0,0 +1,238 @@ |
||||
#include "beeps.h" |
||||
#include <math.h> |
||||
#include <avr/pgmspace.h> |
||||
#include <avr/interrupt.h> |
||||
#include <avr/io.h> |
||||
|
||||
#define PI 3.14159265 |
||||
#define CHANNEL OCR1C |
||||
|
||||
volatile uint16_t sample; |
||||
uint16_t lastSample; |
||||
|
||||
const int sounddata_length=200; |
||||
|
||||
const unsigned char sounddata_data[] PROGMEM = {128,
|
||||
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
|
||||
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
|
||||
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
|
||||
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
|
||||
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
|
||||
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
|
||||
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
|
||||
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
|
||||
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
|
||||
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 129, 127, 129, 128, 127, 133,
|
||||
117, 109, 125, 121, 116, 132, 140, 126, 114, 114, 116, 120, 114, 93, 73, 66, 76, 116, 142, 129,
|
||||
128, 129, 120, 119, 118, 104, 87, 123, 181, 194, 196, 198, 189, 176, 160, 162, 172, 164, 164, 183,
|
||||
197, 188, 168, 167, 170, 165, 185, 209, 206, 196, 196, 199, 185, 162, 156, 167, 176, 173, 170, 166,
|
||||
151, 142, 140, 134, 130, 127, 113, 86, 67, 66, 69, 75, 73, 75, 86, 90, 91, 84, 65, 48,
|
||||
41, 30, 26, 56, 91, 88, 72, 70, 73, 82, 89, 73, 57, 60, 74, 89, 92, 77, 63, 60,
|
||||
53, 47, 56, 64, 63, 61, 56, 54, 52, 36, 16, 22, 51, 66, 67, 70, 76, 88, 99, 92,
|
||||
77, 74, 85, 100, 106, 97, 83, 85, 96, 108, 133, 160, 164}; |
||||
|
||||
void delay_us(int count) { |
||||
while(count--) { |
||||
_delay_us(1); |
||||
} |
||||
} |
||||
|
||||
void beeps() { |
||||
// DDRB |= (1<<7);
|
||||
// PORTB &= ~(1<<7);
|
||||
|
||||
// // Use full 16-bit resolution.
|
||||
// ICR1 = 0xFFFF;
|
||||
|
||||
// // I could write a wall of text here to explain... but TL;DW
|
||||
// // Go read the ATmega32u4 datasheet.
|
||||
// // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
|
||||
|
||||
// // Pin PB7 = OCR1C (Timer 1, Channel C)
|
||||
// // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
|
||||
// // (i.e. start high, go low when counter matches.)
|
||||
// // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
|
||||
// // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
|
||||
|
||||
// TCCR1A = _BV(COM1C1) | _BV(WGM11); // = 0b00001010;
|
||||
// TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
|
||||
|
||||
|
||||
// // Turn off PWM control on PB7, revert to output low.
|
||||
// // TCCR1A &= ~(_BV(COM1C1));
|
||||
// // CHANNEL = ((1 << level) - 1);
|
||||
|
||||
// // Turn on PWM control of PB7
|
||||
// TCCR1A |= _BV(COM1C1);
|
||||
// // CHANNEL = level << OFFSET | 0x0FFF;
|
||||
// // CHANNEL = 0b1010101010101010;
|
||||
|
||||
// float x = 12;
|
||||
// float y = 24;
|
||||
// float length = 50;
|
||||
// float scale = 1;
|
||||
|
||||
// // int f1 = 1000000/440;
|
||||
// // int f2 = 1000000/880;
|
||||
// // for (uint32_t i = 0; i < length * 1000; i++) {
|
||||
// // // int frequency = 1/((sin(PI*2*i*scale*pow(2, x/12.0))*.5+1 + sin(PI*2*i*scale*pow(2, y/12.0))*.5+1) / 2);
|
||||
|
||||
// // ICR1 = f1; // Set max to the period
|
||||
// // OCR1C = f1 >> 1; // Set compare to half the period
|
||||
// // // _delay_us(10);
|
||||
// // }
|
||||
// int frequency = 1000000/440;
|
||||
// ICR1 = frequency; // Set max to the period
|
||||
// OCR1C = frequency >> 1; // Set compare to half the period
|
||||
// _delay_us(500000);
|
||||
|
||||
// TCCR1A &= ~(_BV(COM1C1));
|
||||
// CHANNEL = 0;
|
||||
play_notes(); |
||||
|
||||
|
||||
// play_note(55*pow(2, 0/12.0), 1);
|
||||
// play_note(55*pow(2, 12/12.0), 1);
|
||||
// play_note(55*pow(2, 24/12.0), 1);
|
||||
// play_note(55*pow(2, 0/12.0), 1);
|
||||
// play_note(55*pow(2, 12/12.0), 1);
|
||||
// play_note(55*pow(2, 24/12.0), 1);
|
||||
|
||||
// play_note(0, 4);
|
||||
|
||||
// play_note(55*pow(2, 0/12.0), 8);
|
||||
// play_note(55*pow(2, 12/12.0), 4);
|
||||
// play_note(55*pow(2, 10/12.0), 4);
|
||||
// play_note(55*pow(2, 12/12.0), 8);
|
||||
// play_note(55*pow(2, 10/12.0), 4);
|
||||
// play_note(55*pow(2, 7/12.0), 2);
|
||||
// play_note(55*pow(2, 8/12.0), 2);
|
||||
// play_note(55*pow(2, 7/12.0), 16);
|
||||
// play_note(0, 4);
|
||||
// play_note(55*pow(2, 3/12.0), 8);
|
||||
// play_note(55*pow(2, 5/12.0), 4);
|
||||
// play_note(55*pow(2, 7/12.0), 4);
|
||||
// play_note(55*pow(2, 7/12.0), 8);
|
||||
// play_note(55*pow(2, 5/12.0), 4);
|
||||
// play_note(55*pow(2, 3/12.0), 4);
|
||||
// play_note(55*pow(2, 2/12.0), 16);
|
||||
|
||||
|
||||
} |
||||
|
||||
void play_note(float freq, int length) { |
||||
DDRB |= (1<<7); |
||||
PORTB &= ~(1<<7); |
||||
|
||||
if (freq > 0) { |
||||
int frequency = 1000000/freq; |
||||
ICR1 = frequency; // Set max to the period
|
||||
OCR1C = frequency >> 1; // Set compare to half the period
|
||||
|
||||
TCCR1A = _BV(COM1C1) | _BV(WGM11); // = 0b00001010;
|
||||
TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
|
||||
} |
||||
|
||||
for (int i = 0; i < length; i++) { |
||||
_delay_us(50000); |
||||
} |
||||
|
||||
TCCR1A &= ~(_BV(COM1C1)); |
||||
} |
||||
|
||||
// This is called at 8000 Hz to load the next sample.
|
||||
ISR(TIMER1_COMPA_vect) { |
||||
if (sample >= sounddata_length) { |
||||
if (sample == sounddata_length + lastSample) { |
||||
TIMSK1 &= ~_BV(OCIE1A); |
||||
|
||||
// Disable the per-sample timer completely.
|
||||
TCCR1B &= ~_BV(CS10); |
||||
} |
||||
else { |
||||
OCR1C = sounddata_length + lastSample - sample;
|
||||
} |
||||
} |
||||
else { |
||||
OCR1C = pgm_read_byte(&sounddata_data[sample]);
|
||||
} |
||||
|
||||
++sample; |
||||
} |
||||
|
||||
void play_notes() { |
||||
|
||||
|
||||
// Set up Timer 2 to do pulse width modulation on the speaker
|
||||
// pin.
|
||||
|
||||
DDRB |= (1<<7); |
||||
PORTB &= ~(1<<7); |
||||
|
||||
// Use internal clock (datasheet p.160)
|
||||
// ASSR &= ~(_BV(EXCLK) | _BV(AS2));
|
||||
|
||||
// Set fast PWM mode (p.157)
|
||||
TCCR1A |= _BV(WGM21) | _BV(WGM20); |
||||
TCCR1B &= ~_BV(WGM22); |
||||
|
||||
// Do non-inverting PWM on pin OC2A (p.155)
|
||||
// On the Arduino this is pin 11.
|
||||
TCCR1A = (TCCR2A | _BV(COM2A1)) & ~_BV(COM2A0); |
||||
TCCR1A &= ~(_BV(COM2B1) | _BV(COM2B0)); |
||||
// No prescaler (p.158)
|
||||
TCCR1B = (TCCR1B & ~(_BV(CS12) | _BV(CS11))) | _BV(CS10); |
||||
|
||||
// Set initial pulse width to the first sample.
|
||||
OCR1A = pgm_read_byte(&sounddata_data[0]); |
||||
|
||||
|
||||
|
||||
|
||||
cli(); |
||||
|
||||
// Set CTC mode (Clear Timer on Compare Match) (p.133)
|
||||
// Have to set OCR1A *after*, otherwise it gets reset to 0!
|
||||
TCCR2B = (TCCR2B & ~_BV(WGM13)) | _BV(WGM12); |
||||
TCCR2A = TCCR2A & ~(_BV(WGM11) | _BV(WGM10)); |
||||
|
||||
// No prescaler (p.134)
|
||||
TCCR2B = (TCCR2B & ~(_BV(CS12) | _BV(CS11))) | _BV(CS10); |
||||
|
||||
// Set the compare register (OCR1A).
|
||||
// OCR1A is a 16-bit register, so we have to do this with
|
||||
// interrupts disabled to be safe.
|
||||
// OCR2A = F_CPU / SAMPLE_RATE; // 16e6 / 8000 = 2000
|
||||
OCR2A = 2000; |
||||
|
||||
// Enable interrupt when TCNT1 == OCR1A (p.136)
|
||||
TIMSK1 |= _BV(OCIE2A); |
||||
|
||||
sample = 0; |
||||
sei(); |
||||
} |
||||
|
||||
void note(int x, float length) { |
||||
DDRB |= (1<<1); |
||||
int t = (int)(440*pow(2,-x/12.0)); // starting note
|
||||
for (int y = 0; y < length*1000/t; y++) { // note length
|
||||
PORTB |= (1<<1); |
||||
delay_us(t); |
||||
PORTB &= ~(1<<1); |
||||
delay_us(t); |
||||
} |
||||
PORTB &= ~(1<<1); |
||||
} |
||||
|
||||
void true_note(float x, float y, float length) { |
||||
for (uint32_t i = 0; i < length * 50; i++) { |
||||
uint32_t v = (uint32_t) (round(sin(PI*2*i*640000*pow(2, x/12.0))*.5+1 + sin(PI*2*i*640000*pow(2, y/12.0))*.5+1) / 2 * pow(2, 8));
|
||||
for (int u = 0; u < 8; u++) { |
||||
if (v & (1 << u) && !(PORTB&(1<<1))) |
||||
PORTB |= (1<<1); |
||||
else if (PORTB&(1<<1)) |
||||
PORTB &= ~(1<<1); |
||||
} |
||||
} |
||||
PORTB &= ~(1<<1); |
||||
} |
||||
@ -0,0 +1,9 @@ |
||||
#include <stdint.h> |
||||
#include <stdbool.h> |
||||
#include <avr/io.h> |
||||
#include <util/delay.h> |
||||
|
||||
void note(int x, float length); |
||||
void beeps(); |
||||
void true_note(float x, float y, float length); |
||||
void play_note(float freq, int length); |
||||
@ -0,0 +1,49 @@ |
||||
#include "keymap_common.h" |
||||
|
||||
const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
||||
[0] = KEYMAP( /* Paul */ |
||||
TAB, Q, W, E, R, T, Y, U, I, O, P, BSPC, |
||||
FN1, A, S, D, F, G, H, J, K, L, SCLN, QUOT, |
||||
LSFT, Z, X, C, V, B, N, M, COMM, DOT, SLSH, ENT, |
||||
ESC, LCTL, LALT, LGUI, FN2, SPC, FN3, LEFT, DOWN, UP, RGHT), |
||||
[1] = KEYMAP( /* Paul FN */ |
||||
TRNS, TRNS, TRNS, FN8, FN9, TRNS, TRNS, TRNS, TRNS, MUTE, VOLD, VOLU, |
||||
FN1, TRNS, TRNS, HOME, END, TRNS, TRNS, TRNS, TRNS, MPRV, MPLY, MNXT, |
||||
TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, UP, TRNS, |
||||
TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, LEFT, DOWN, RGHT), |
||||
[2] = KEYMAP( /* Paul LOWER */ |
||||
FN22, FN10, FN11, FN12, FN13, FN14, FN15, FN16, FN17, FN18, FN19, BSPC, |
||||
TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, FN20, FN21, FN23, FN24, FN28, |
||||
TRNS, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, TRNS, |
||||
TRNS, TRNS, TRNS, TRNS, FN2, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS), |
||||
[3] = KEYMAP( /* Paul RAISE */ |
||||
GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, BSPC, |
||||
TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, MINS, EQL, LBRC, RBRC, BSLS, |
||||
TRNS, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, TRNS, |
||||
TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, FN3, TRNS, TRNS, TRNS, TRNS), |
||||
}; |
||||
const uint16_t PROGMEM fn_actions[] = { |
||||
[1] = ACTION_LAYER_MOMENTARY(1), // to Fn1 overlay (FN)
|
||||
[2] = ACTION_LAYER_MOMENTARY(2), // to Fn2 overlay (LOWER)
|
||||
[3] = ACTION_LAYER_MOMENTARY(3), // to Fn3 overlay (RAISE)
|
||||
|
||||
[8] = ACTION_MODS_KEY(MOD_LSFT, KC_HOME), |
||||
[9] = ACTION_MODS_KEY(MOD_LSFT, KC_END), |
||||
[10] = ACTION_MODS_KEY(MOD_LSFT, KC_1), |
||||
[11] = ACTION_MODS_KEY(MOD_LSFT, KC_2), |
||||
[12] = ACTION_MODS_KEY(MOD_LSFT, KC_3), |
||||
[13] = ACTION_MODS_KEY(MOD_LSFT, KC_4), |
||||
[14] = ACTION_MODS_KEY(MOD_LSFT, KC_5), |
||||
[15] = ACTION_MODS_KEY(MOD_LSFT, KC_6), |
||||
[16] = ACTION_MODS_KEY(MOD_LSFT, KC_7), |
||||
[17] = ACTION_MODS_KEY(MOD_LSFT, KC_8), |
||||
[18] = ACTION_MODS_KEY(MOD_LSFT, KC_9), |
||||
[19] = ACTION_MODS_KEY(MOD_LSFT, KC_0), |
||||
[20] = ACTION_MODS_KEY(MOD_LSFT, KC_MINS), |
||||
[21] = ACTION_MODS_KEY(MOD_LSFT, KC_EQL), |
||||
[22] = ACTION_MODS_KEY(MOD_LSFT, KC_GRV), |
||||
[23] = ACTION_MODS_KEY(MOD_LSFT, KC_LBRC), |
||||
[24] = ACTION_MODS_KEY(MOD_LSFT, KC_RBRC), |
||||
[28] = ACTION_MODS_KEY(MOD_LSFT, KC_BSLS), |
||||
|
||||
}; |
||||
@ -0,0 +1,76 @@ |
||||
#include "extended_keymap_common.h" |
||||
#include "beeps.h" |
||||
|
||||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
||||
[0] = { /* Qwerty */ |
||||
{KC_Q, KC_W, KC_E, KC_R, KC_T, KC_BSPC, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC}, |
||||
{KC_A, KC_S, KC_D, KC_F, KC_G, KC_ENT, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT}, |
||||
{KC_Z, KC_X, KC_C, KC_V, KC_B, KC_ESC, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT}, |
||||
{M(10), KC_LCTL, KC_LALT, KC_LGUI, FUNC(2), KC_SPC, KC_SPC, FUNC(1), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT} |
||||
// Space is repeated to accommadate for both spacebar wiring positions
|
||||
}, |
||||
[1] = { /* Colemak */ |
||||
{KC_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSPC}, |
||||
{KC_ESC, 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_FN3, KC_LCTL, KC_LALT, KC_LGUI, FUNC(2), KC_SPC, KC_SPC, FUNC(1), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT} |
||||
}, |
||||
[2] = { /* RAISE */ |
||||
{KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC}, |
||||
{KC_TRNS, FUNC(3), FUNC(4), RESET, M(0), M(1), M(2), KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS}, |
||||
{KC_TRNS, KC_F11, KC_F12, M(0), M(1), M(2), M(3), M(4), M(5), M(6), M(7), KC_TRNS}, |
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(1), KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY} |
||||
}, |
||||
[3] = { /* LOWER */ |
||||
{S(KC_GRV), S(KC_1), S(KC_2), S(KC_3), S(KC_4), S(KC_5), S(KC_6), S(KC_7), S(KC_8), S(KC_9), S(KC_0), KC_BSPC}, |
||||
{KC_TRNS, FUNC(3), FUNC(4), RESET, M(0), M(1), M(2), S(KC_MINS), S(KC_EQL), S(KC_LBRC), S(KC_RBRC), S(KC_BSLS)}, |
||||
{KC_TRNS, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_TRNS}, |
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(2), KC_TRNS, KC_TRNS, KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY} |
||||
} |
||||
}; |
||||
|
||||
const uint16_t PROGMEM fn_actions[] = { |
||||
[1] = ACTION_LAYER_MOMENTARY(2), // to RAISE
|
||||
[2] = ACTION_LAYER_MOMENTARY(3), // to LOWER
|
||||
|
||||
[3] = ACTION_DEFAULT_LAYER_SET(0), |
||||
[4] = ACTION_DEFAULT_LAYER_SET(1), |
||||
|
||||
}; |
||||
|
||||
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
|
||||
{ |
||||
// MACRODOWN only works in this function
|
||||
if (record->event.pressed) { |
||||
switch(id) { |
||||
case 0: |
||||
true_note(12, 12, 20); |
||||
break; |
||||
case 1: |
||||
true_note(14, 14, 20); |
||||
break; |
||||
case 2: |
||||
true_note(16, 16, 20); |
||||
break; |
||||
case 3: |
||||
true_note(17, 17, 20); |
||||
break; |
||||
case 4: |
||||
true_note(19, 19, 20); |
||||
break; |
||||
case 5: |
||||
true_note(21, 21, 20); |
||||
break; |
||||
case 6: |
||||
true_note(23, 23, 20); |
||||
break; |
||||
case 7: |
||||
true_note(24, 24, 20); |
||||
break; |
||||
case 10: |
||||
|
||||
break; |
||||
}
|
||||
} |
||||
return MACRO_NONE; |
||||
}; |
||||
@ -0,0 +1,49 @@ |
||||
#include "extended_keymap_common.h" |
||||
|
||||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
||||
[0] = { /* Qwerty */ |
||||
{KC_ESC, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_TAB}, |
||||
{KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_BSPC}, |
||||
{KC_LALT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT}, |
||||
{KC_FN4, KC_RSFT, KC_LGUI, KC_LSFT, FUNC(2), KC_SPC, KC_SPC, FUNC(1), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT} |
||||
// Space is repeated to accommadate for both spacebar wiring positions
|
||||
}, |
||||
[1] = { /* Colemak */ |
||||
{KC_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_TAB}, |
||||
{KC_ESC, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_BSPC}, |
||||
{KC_LALT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT}, |
||||
{KC_FN3, KC_RSFT, KC_LGUI, KC_LSFT, FUNC(2), KC_SPC, KC_SPC, FUNC(1), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT} |
||||
}, |
||||
[2] = { /* RAISE */ |
||||
{KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12}, |
||||
{KC_TRNS, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_DEL}, |
||||
{KC_TRNS, KC_GRV, KC_MINS, KC_EQL, KC_QUOT, S(KC_QUOT), S(KC_LBRC), S(KC_RBRC), KC_LBRC, KC_RBRC, KC_BSLS, KC_TRNS}, |
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(1), KC_HOME, KC_PGUP, KC_PGDN, KC_END} |
||||
}, |
||||
[3] = { /* LOWER */ |
||||
{KC_POWER,KC_PSCR, KC_SLCK, KC_PAUSE, KC_NLCK, KC_EXECUTE, KC_MENU, KC_APP, KC_7, KC_8, KC_9, KC_KP_SLASH}, |
||||
{KC_TRNS, KC_VOLD, KC_VOLU, KC_MUTE, KC_CAPS, KC_CANCEL, KC_UNDO, KC_AGAIN, KC_4, KC_5, KC_6, KC_KP_ASTERISK}, |
||||
{KC_TRNS, KC_INSERT,KC_CUT, KC_COPY, KC_PASTE, KC_BSLS, KC_9, KC_0, KC_1, KC_2, KC_3, KC_KP_MINUS}, |
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(2), KC_TRNS, KC_TRNS, KC_TRNS, KC_0, KC_KP_DOT, KC_KP_ENTER, KC_KP_PLUS} |
||||
} |
||||
}; |
||||
|
||||
const uint16_t PROGMEM fn_actions[] = { |
||||
[1] = ACTION_LAYER_MOMENTARY(2), // to RAISE
|
||||
[2] = ACTION_LAYER_MOMENTARY(3), // to LOWER
|
||||
|
||||
[3] = ACTION_DEFAULT_LAYER_SET(0), |
||||
[4] = ACTION_DEFAULT_LAYER_SET(1), |
||||
|
||||
}; |
||||
|
||||
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
|
||||
{ |
||||
// MACRODOWN only works in this function
|
||||
switch(id) { |
||||
case 0: |
||||
return MACRODOWN(T(CM_T), END); |
||||
break; |
||||
}
|
||||
return MACRO_NONE; |
||||
}; |
||||
@ -0,0 +1,49 @@ |
||||
#include "extended_keymap_common.h" |
||||
|
||||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
||||
[0] = { /* Qwerty */ |
||||
{KC_ESC, 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_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_RCTL, KC_LCTL, KC_LALT, KC_LGUI, FUNC(2), KC_SPC, KC_SPC, FUNC(1), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT} |
||||
// Space is repeated to accommadate for both spacebar wiring positions
|
||||
}, |
||||
[1] = { /* Colemak */ |
||||
{KC_ESC, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSPC}, |
||||
{KC_TAB, 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_FN3, KC_LCTL, KC_LALT, KC_LGUI, FUNC(2), KC_SPC, KC_SPC, FUNC(1), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT} |
||||
}, |
||||
[2] = { /* RAISE */ |
||||
{KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC}, |
||||
{KC_TRNS, FUNC(3), FUNC(4), LSFT(RSFT(KC_PAUSE)), KC_TRNS, KC_TRNS, KC_TRNS, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS}, |
||||
{KC_TRNS, KC_F11, KC_F12, KC_F13, KC_F14, KC_F15, KC_F16, KC_F17, KC_F18, KC_F19, KC_F20, KC_TRNS}, |
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(1), KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY} |
||||
}, |
||||
[3] = { /* LOWER */ |
||||
{S(KC_GRV), S(KC_1), S(KC_2), S(KC_3), S(KC_4), S(KC_5), S(KC_6), S(KC_7), S(KC_8), S(KC_9), S(KC_0), KC_BSPC}, |
||||
{KC_TRNS, FUNC(3), FUNC(4), LSFT(RSFT(KC_PAUSE)), LSFT(RSFT(KC_D)), KC_TRNS, KC_TRNS, S(KC_MINS), S(KC_EQL), S(KC_LBRC), S(KC_RBRC), S(KC_BSLS)}, |
||||
{KC_TRNS, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_TRNS}, |
||||
{BL_STEP, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(2), KC_TRNS, KC_TRNS, KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY} |
||||
} |
||||
}; |
||||
|
||||
const uint16_t PROGMEM fn_actions[] = { |
||||
[1] = ACTION_LAYER_MOMENTARY(2), // to RAISE
|
||||
[2] = ACTION_LAYER_MOMENTARY(3), // to LOWER
|
||||
|
||||
[3] = ACTION_DEFAULT_LAYER_SET(0), |
||||
[4] = ACTION_DEFAULT_LAYER_SET(1), |
||||
|
||||
}; |
||||
|
||||
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
|
||||
{ |
||||
// MACRODOWN only works in this function
|
||||
switch(id) { |
||||
case 0: |
||||
return MACRODOWN(T(CM_T), END); |
||||
break; |
||||
}
|
||||
return MACRO_NONE; |
||||
}; |
||||
@ -0,0 +1,46 @@ |
||||
#include "extended_keymap_common.h" |
||||
|
||||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
||||
[0] = { /* BASE */ |
||||
{KC_ESC, KC_LBRC, KC_QUOT, KC_SCLN, KC_P, KC_Y, KC_F, KC_G, KC_C, KC_R, KC_L, KC_BSPC}, |
||||
{KC_TAB, KC_A, KC_O, KC_E, KC_U, KC_I, KC_D, KC_H, KC_T, KC_N, KC_S, KC_ENT}, |
||||
{KC_LSFT, KC_DOT, KC_Q, KC_J, KC_K, KC_X, KC_B, KC_M, KC_W, KC_V, KC_Z, KC_COMM}, |
||||
{KC_LCTL, KC_LALT, KC_LGUI, FUNC(3), FUNC(2), KC_SPC, KC_SPC, FUNC(1), FUNC(3), KC_RGUI, KC_RALT, KC_RCTL} |
||||
}, |
||||
[2] = { /* RAISE */ |
||||
{RALT(KC_RBRC), KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, S(KC_RBRC)}, |
||||
{KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12}, |
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS}, |
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS} |
||||
}, |
||||
[3] = { /* LOWER */ |
||||
{S(KC_EQL),S(KC_1),S(KC_2),S(KC_3),RALT(KC_5),S(KC_5), S(KC_6), S(KC_7),RALT(KC_7),RALT(KC_0),S(KC_0), KC_MINS}, |
||||
{KC_TRNS,RALT(KC_2),S(KC_SLSH),KC_NUBS,S(KC_NUBS),RALT(KC_MINS),RALT(KC_NUBS), KC_NUHS, S(KC_8), S(KC_9), S(KC_MINS), KC_SLSH}, |
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RALT(KC_8), RALT(KC_9), KC_TRNS, KC_TRNS}, |
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS} |
||||
}, |
||||
[4] = { /* META */ |
||||
{KC_TRNS, KC_HOME, KC_UP, KC_END, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_UP, KC_END, KC_TRNS, KC_DEL}, |
||||
{KC_TRNS, KC_RGHT, KC_DOWN, KC_LEFT, KC_PGUP, KC_TRNS, KC_PGUP, KC_LEFT, KC_DOWN, KC_RGHT, KC_TRNS, KC_TRNS}, |
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PGDN, KC_TRNS, KC_PGDN, KC_TRNS, KC_VOLD, KC_VOLU, KC_TRNS, KC_TRNS}, |
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS} |
||||
} |
||||
}; |
||||
|
||||
const uint16_t PROGMEM fn_actions[] = { |
||||
[1] = ACTION_LAYER_MOMENTARY(2), // to RAISE
|
||||
[2] = ACTION_LAYER_MOMENTARY(3), // to LOWER
|
||||
[3] = ACTION_LAYER_MOMENTARY(4), // to META
|
||||
|
||||
}; |
||||
|
||||
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
|
||||
{ |
||||
// MACRODOWN only works in this function
|
||||
switch(id) { |
||||
case 0: |
||||
return MACRODOWN(T(CM_T), END); |
||||
break; |
||||
}
|
||||
return MACRO_NONE; |
||||
}; |
||||
@ -0,0 +1,49 @@ |
||||
#include "extended_keymap_common.h" |
||||
|
||||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
||||
[0] = { /* Qwerty */ |
||||
{KC_ESC, 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_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_ENT }, |
||||
{KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_QUOT}, |
||||
{KC_LCTL, BL_STEP, KC_LALT, KC_LGUI, FUNC(2), KC_SPC, KC_SPC, FUNC(1), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT} |
||||
// Space is repeated to accommadate for both spacebar wiring positions
|
||||
}, |
||||
[1] = { /* Colemak */ |
||||
{KC_ESC, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSPC}, |
||||
{KC_TAB, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_ENT }, |
||||
{KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_QUOT}, |
||||
{KC_LCTL, BL_STEP, KC_LALT, KC_LGUI, FUNC(2), KC_SPC, KC_SPC, FUNC(1), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT} |
||||
}, |
||||
[2] = { /* RAISE */ |
||||
{KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC}, |
||||
{KC_TRNS, FUNC(3), FUNC(4), RESET, KC_TRNS, KC_TRNS, KC_TRNS, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_TRNS}, |
||||
{KC_TRNS, KC_F11, KC_F12, KC_F13, KC_F14, KC_F15, KC_F16, KC_F17, KC_F18, KC_F19, KC_F20, KC_BSLS}, |
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(1), KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY} |
||||
}, |
||||
[3] = { /* LOWER */ |
||||
{S(KC_GRV), S(KC_1), S(KC_2), S(KC_3), S(KC_4), S(KC_5), S(KC_6), S(KC_7), S(KC_8), S(KC_9), S(KC_0), KC_BSPC}, |
||||
{KC_TRNS, FUNC(3), FUNC(4), RESET, KC_TRNS, KC_TRNS, KC_TRNS, S(KC_MINS), S(KC_EQL), S(KC_LBRC), S(KC_RBRC), KC_TRNS}, |
||||
{KC_TRNS, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, S(KC_BSLS)}, |
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(2), KC_TRNS, KC_TRNS, KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY} |
||||
} |
||||
}; |
||||
|
||||
const uint16_t PROGMEM fn_actions[] = { |
||||
[1] = ACTION_LAYER_MOMENTARY(2), // to RAISE
|
||||
[2] = ACTION_LAYER_MOMENTARY(3), // to LOWER
|
||||
|
||||
[3] = ACTION_DEFAULT_LAYER_SET(0), |
||||
[4] = ACTION_DEFAULT_LAYER_SET(1), |
||||
|
||||
}; |
||||
|
||||
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
|
||||
{ |
||||
// MACRODOWN only works in this function
|
||||
switch(id) { |
||||
case 0: |
||||
return MACRODOWN(T(CM_T), END); |
||||
break; |
||||
}
|
||||
return MACRO_NONE; |
||||
}; |
||||
@ -0,0 +1,26 @@ |
||||
#include "extended_keymap_common.h" |
||||
|
||||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { |
||||
[0] = { /* Qwerty */ |
||||
{KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_KP_MINUS, KC_KP_PLUS, KC_KP_PLUS, KC_KP_ENTER, KC_KP_ENTER}, |
||||
{KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_KP_ASTERISK, KC_KP_9, KC_KP_6, KC_KP_3, KC_KP_DOT}, |
||||
{KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_KP_SLASH, KC_KP_8, KC_KP_5, KC_KP_2, KC_KP_0}, |
||||
{BL_STEP, KC_LCTL, KC_LALT, KC_LGUI, KC_NO, KC_SPC, KC_SPC, KC_NUMLOCK, KC_KP_7, KC_KP_4, KC_KP_1, KC_KP_0} |
||||
// Space is repeated to accommadate for both spacebar wiring positions
|
||||
} |
||||
}; |
||||
|
||||
const uint16_t PROGMEM fn_actions[] = { |
||||
|
||||
}; |
||||
|
||||
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
|
||||
{ |
||||
// MACRODOWN only works in this function
|
||||
switch(id) { |
||||
case 0: |
||||
return MACRODOWN(T(CM_T), END); |
||||
break; |
||||
}
|
||||
return MACRO_NONE; |
||||
}; |
||||
@ -0,0 +1,3 @@ |
||||
dfu-programmer atmega32u4 erase --force |
||||
dfu-programmer atmega32u4 flash planck_pcb.hex |
||||
dfu-programmer atmega32u4 reset |
||||
Loading…
Reference in new issue