pull/26/head
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