int main() {
init();
//blink(1);
while(1) {
//DEBUG("\r\n");
clear_keys();
//debounce(DEBOUNCE_PASSES);
scan_keys();
cool_down_inactive_layers();
pre_invoke_functions();
calculate_presses();
//b();
//clear_screen();
//debug_state();
//debug_layers();
usb_keyboard_send();
};
};
//Sends a keyboard report depending on active protocol
void keyboard_send_report( )
{
//Debug toggle bluetooth status
//Check to see if USB active
if(bluefruit_configured())
{
//Send keyboard report using Bluetooth
bluefruit_keyboard_send();
print("Sent Bluetooth Report!\n");
}
else
{
//Send keyboard report using USB
usb_keyboard_send();
//bluefruit_keyboard_send(); //debug also send bluetooth report
print("Sent USB Report!\n");
}
}
void usb_keyboard_press_keycode(uint16_t n)
{
uint8_t key, mod, msb, modrestore=0;
KEYCODE_TYPE keycode;
#ifdef DEADKEYS_MASK
KEYCODE_TYPE deadkeycode;
#endif
msb = n >> 8;
if (msb >= 0xC2 && msb <= 0xDF) {
n = (n & 0x3F) | ((uint16_t)(msb & 0x1F) << 6);
} else
if (msb == 0x80) {
usb_keyboard_press_key(0, n);
return;
} else
if (msb == 0x40) {
usb_keyboard_press_key(n, 0);
return;
}
keycode = unicode_to_keycode(n);
if (!keycode) return;
#ifdef DEADKEYS_MASK
deadkeycode = deadkey_to_keycode(keycode);
if (deadkeycode) {
modrestore = keyboard_modifier_keys;
if (modrestore) {
keyboard_modifier_keys = 0;
usb_keyboard_send();
}
// TODO: test if operating systems recognize
// deadkey sequences when other keys are held
mod = keycode_to_modifier(deadkeycode);
key = keycode_to_key(deadkeycode);
usb_keyboard_press_key(key, mod);
usb_keyboard_release_key(key, mod);
}
#endif
mod = keycode_to_modifier(keycode);
key = keycode_to_key(keycode);
usb_keyboard_press_key(key, mod | modrestore);
}
static void usb_keyboard_release_key(uint8_t key, uint8_t modifier)
{
int i, send_required = 0;
if (modifier) {
if ((keyboard_modifier_keys & modifier) != 0) {
keyboard_modifier_keys &= ~modifier;
send_required = 1;
}
}
if (key) {
for (i=0; i < 6; i++) {
if (keyboard_keys[i] == key) {
keyboard_keys[i] = 0;
send_required = 1;
}
}
}
if (send_required) usb_keyboard_send();
}
void pokerMode(){
while (1) {
for (r = 0; r < ROWS; r++) {
pullDownRows(r);
read_cols(r);
unselect_rows();
}
for (r = 0; r < ROWS; r++) {
for (c = 0; c < COLS; c++) {
if (keystate[r][c] > 0x08) {
if (keytype[r][c] == 0x01) {
if (FN == 0x00)
presskey(hexaKeys[r][c]);
else if (FN == 0x01)
presskey(hexaKeys2[r][c]);
} else if (keytype[r][c] == 0x02) {
pressModifierKeys(hexaKeys[r][c]);
} else if (keytype[r][c] == 0x04 && FN == 0x00) {
FN = 0x02;
}
} else {
if (keytype[r][c] == 0x01) {
if (FN == 0x00)
releasekey(hexaKeys[r][c]);
else if (FN == 0x01)
releasekey(hexaKeys2[r][c]);
} else if (keytype[r][c] == 0x02) {
releaseModifierKeys(hexaKeys[r][c]);
} else if (keytype[r][c] == 0x04 && FN == 0x01) {
FN = 0x04;
}
}
}
}
if(FN==0x02){FN=0x01;releaseAll();}
else if(FN==0x04){FN=0x00;releaseAll();}
usb_keyboard_send();
///////////////////////////////////
}
}
void osuMode(){
DDRD |= (1 << 0);
PORTD &= ~(1 << 0);
DDRD |= (1 << 1);
PORTD &= ~(1 << 1);
DDRD |= (1 << 2);
PORTD &= ~(1 << 2);
DDRD |= (1 << 3);
PORTD &= ~(1 << 3);
DDRD |= (1 << 5);
PORTD &= ~(1 << 5);
while (1) {
if(PINF & (1 << 0)){keyboard_keys[0] = 0;}else{keyboard_keys[0]=KEY_ESC;}
if(PINE & (1 << 6)){keyboard_keys[1] = 0;}else{keyboard_keys[1]=KEY_Z;}
if(PINC & (1 << 7)){keyboard_keys[2] = 0;}else{keyboard_keys[2]=KEY_X;}
if(PINB & (1 << 7)){keyboard_keys[3] = 0;}else{keyboard_keys[3]=KEY_SPACE;}
if(PINB & (1 << 3)){keyboard_keys[4] = 0;}else{keyboard_keys[4]=KEY_ENTER;}
usb_keyboard_send();
}
}
void _kbfun_combo_normal_press_release_once(keycode combo_key, keycode key, bool is_pressed) {
// FIXME this should be cleaner when we have actual key repeats
if (is_pressed) {
// avoid messing with independently pressed modifiers
bool mod_already_pressed = _kbfun_modifier_is_pressed(combo_key);
if (!mod_already_pressed) {
_kbfun_modifier_press_release(combo_key, true);
}
kbfun_normal_press_release(key, true);
if (!mod_already_pressed) {
// we force a keyboard send to prevent the modifier from bleeding into the next key press
usb_keyboard_send();
_kbfun_modifier_press_release(combo_key, false);
}
} else {
kbfun_normal_press_release(key, false);
}
}
//Main Program
int main(void)
{
uint8_t b_prev=0xFF, c_prev=0xFF, d_prev=0xFF;
// set for 16 MHz clock
CLKPR = 0x80, CLKPR = 0;
// Configure all ports as inputs with pullup resistors.
DDRB = 0x00;
DDRC = 0x00;
DDRD = 0x00;
PORTB = 0xFF;
PORTC = 0xFF;
PORTD = 0xFF;
//Initialise LED timings (added v1.1)
clock_prescale_set(clock_div_1);
MCUSR &= ~(1 << WDRF);
wdt_disable();
//Read eeprom to get active group and mode
ee_byte=read_eeprom_byte(1);
set_active_mode();
// Initialize the USB
usb_init();
//flash them leds
#include "../shared/disco.c"
while(!usb_configured());
// Wait for host to load drivers
//_delay_ms(500);
while(1) {
uint8_t b = PINB;
uint8_t c = PINC;
uint8_t d = PIND;
if(b != b_prev || c != c_prev || d != d_prev ) {
keycount = 0;
modecount = 0; //HWB to toggle active mode
//if(!(c & 0x10)) //Pin B10 can be connected to external LED indicator
if(!(c & 0x20)) { keyboard_keys[keycount++] = map[18]; } //PIN B9
if(!(c & 0x40)) { keyboard_keys[keycount++] = map[17]; } //PIN B8
if(!(c & 0x80)) { keyboard_keys[keycount++] = map[16]; } //PIN B7
if(!(b & 0x80)) { keyboard_keys[keycount++] = map[15]; } //PIN B6
if(!(b & 0x40)) { keyboard_keys[keycount++] = map[14]; } //PIN B5
if(!(b & 0x20)) { keyboard_keys[keycount++] = map[13]; } //PIN B4
if(!(b & 0x10)) { keyboard_keys[keycount++] = map[12]; } //PIN B3
if(!(b & 0x08)) { keyboard_keys[keycount++] = map[11]; } //PIN B2
if(!(b & 0x04)) { keyboard_keys[keycount++] = map[10]; } //PIN B1
if(!(b & 0x02)) { keyboard_keys[keycount++] = map[9]; } //PIN A10
if(!(b & 0x01)) { keyboard_keys[keycount++] = map[8]; } //PIN A9
if(!(d & 0x40)) { keyboard_keys[keycount++] = map[7]; } //PIN A8
if(!(d & 0x20)) { keyboard_keys[keycount++] = map[6]; } //PIN A7
if(!(d & 0x10)) { keyboard_keys[keycount++] = map[5]; } //PIN A6
if(!(d & 0x08)) { keyboard_keys[keycount++] = map[4]; } //PIN A5
if(!(d & 0x04)) { keyboard_keys[keycount++] = map[3]; } //PIN A4
if(!(d & 0x02)) { keyboard_keys[keycount++] = map[2]; } //PIN A3
if(!(d & 0x01)) { keyboard_keys[keycount++] = map[1]; } //PIN A2
if(!(c & 0x04)) { keyboard_keys[keycount++] = map[0]; } //PIN A1
if(!(d & 0x80)) { //HWB PIN
modecount++;
}
while(keycount < sizeof(keyboard_keys)) {
keyboard_keys[keycount++] = KEY_NONE;
}
usb_keyboard_send();
b_prev = b;
c_prev = c;
d_prev = d;
if (modecount>0){
switch_mode();
}
}
_delay_ms(2); // Debounce
}
}
//Main Program
int main(void)
{
// set for 16 MHz clock
CLKPR = 0x80, CLKPR = 0;
//Initialise LED timings (added v1.1)
clock_prescale_set(clock_div_1);
//Set initial pin states. These are adjusted based on eeprom settings.
DDRB=0x00;
DDRC=0x00;
DDRD=0x00;
PORTB=0xFF;
PORTC=0xFF;
PORTD=0xFF;
//pin assignments and button states
uint8_t pos=0, cnt=0;
uint8_t ass[40], state[20];
//handle shift and shift lock
uint8_t shift=0, shift_last=0, shift_count=0, shift_lock=0;
//extended mode flags - use to detect if key combos are pressed
uint8_t p1, p2, p3, p4;
uint8_t ext_inputs, ext_func_block, ext_func;
//Flash LEDs
#include "..\shared\disco.c"
//read first 40 eeprom into an array (pins + shifted pins)
for(cnt=0;cnt<40;cnt++){
ass[cnt]=read_eeprom_byte(cnt);
/*//set output pins
if ((ass[cnt]==28)||(ass[cnt]==29)){
#include "..\shared\outputs.c"
}*/
}
// Initialize the USB
usb_init();
while(!usb_configured());
while(1) {
//read KADE pin states into an array
#include "..\shared\state.c"
//set shifted status and detect shift lock (double click)
#include "..\shared\shift.c"
//check for extended mode inputs
p1=0; p2=0; p3=0; p4=0;
for(cnt=0;cnt<20;cnt++) {
pos=cnt;
if (!(state[cnt])) {
//there is input on this pin
if (shift==1){pos=pos+20;} //+20 if this is shifted input
if (ass[pos]>0) {
if (ass[pos]==3 ||ass[pos]==4 ){ p1 += 1; }
if (ass[pos]==5 ||ass[pos]==6 ){ p1 += 3; }
if (ass[pos]==17||ass[pos]==18){ p2 += 1; }
if (ass[pos]==19||ass[pos]==20){ p2 += 3; }
if (ass[pos]==31||ass[pos]==32){ p3 += 1; }
if (ass[pos]==33||ass[pos]==34){ p3 += 3; }
if (ass[pos]==43||ass[pos]==44){ p4 += 1; }
if (ass[pos]==45||ass[pos]==46){ p4 += 3; }
}
}
}
//Cycle players and process extended maps
//ext_func_block: sets the start position of the extended functions read from eeprom
//ext_inputs: the calculated combo value between 0 and 8.
// 0: .
// 1: .
// 2: up+down
// 3: .
// 4: .
// 5: up+down
// 6: left+right
// 7: left+right
// 8: up+down+left+right
keycount = 0;
for(cnt=0;cnt<4;cnt++) {
if(cnt==0){ext_inputs = p1; ext_func_block = 69;}
if(cnt==1){ext_inputs = p2; ext_func_block = 72;}
if(cnt==2){ext_inputs = p3; ext_func_block = 75;}
if(cnt==3){ext_inputs = p4; ext_func_block = 78;}
if (ext_inputs==2||ext_inputs>=5){
//extended combo is detected
if (ext_inputs==8)
{ext_func=ext_func_block+2;} //(u+d+l+r)
else if (ext_inputs==2||ext_inputs==5)
{ext_func=ext_func_block;} //(u+d)
else if (ext_inputs==6||ext_inputs==7)
{ext_func=ext_func_block+1;} //(l+r)
//shifted function are higher in eeprom
if (shift==1){ext_func=ext_func+12;}
ass[pos] = read_eeprom_byte(ext_func);
#include "keymaps.c"
}
}
//loop through pins checking for inputs from those that are assigned a function
for(cnt=0;cnt<20;cnt++) {
pos=cnt;
if (!(state[cnt])) {
//there is input on this pin
if (shift==1){pos=pos+20;} //+20 if this is shifted input
if (ass[pos]>0) {
//there is an assignment to a function
#include "keymaps_extended.c"
}
}
}
while(keycount < sizeof(keyboard_keys)) {
keyboard_keys[keycount++] = KEY_NONE;
}
usb_keyboard_send();
_delay_ms(2); // Debounce
}
}
void
send_keys(uint8_t* state)
{
// Report all currently pressed keys to the host. This function
// will be called when a change of state has been detected.
uint8_t local = 0;
uint8_t caps_lock_pressed = 0;
const uint8_t* keymap = keymap_normal;
retry:
// If we detect that we are in f-mode, we need to translate the
// pressed keys with the f-mode translation table. Detection of
// f-mode happens while decoding the shift register. When the
// f-mode key is detected as being pressed, the translation table is
// switched and the decoding process is restarted.
{
uint8_t key_index = 0;
uint8_t map_index = 0;
keyboard_modifier_keys = 0;
memset(keyboard_keys, 0, sizeof keyboard_keys);
for (int i = 0; i < 16; i++) {
uint8_t buf = state[i];
for (int j = 0; j < 8; j++, map_index++) {
uint8_t mapped = pgm_read_byte(&keymap[map_index]);
uint8_t pressed = (buf & 1);
#if defined(DEBUG)
if (pressed) {
print("key ");
phex(map_index - 1);
print(" pressed, mapped to ");
phex(mapped);
print("\n");
}
#endif
// Handle firmware update key combination Local+Abort
if (pressed) {
if (map_index == 0x01) {
local = 1; // Local key is pressed
} else if (map_index == 0x1e && local) {
jump_to_loader(); // Abort key is pressed
}
}
if (pressed && mapped) {
if (mapped & 0x80) {
int num = mapped & 0x7F;
switch (num) {
case NUM_KEY_LEFT_CTRL:
case NUM_KEY_LEFT_SHIFT:
case NUM_KEY_LEFT_ALT:
case NUM_KEY_LEFT_GUI:
case NUM_KEY_RIGHT_CTRL:
case NUM_KEY_RIGHT_SHIFT:
case NUM_KEY_RIGHT_ALT:
case NUM_KEY_RIGHT_GUI:
keyboard_modifier_keys |= 1 << num;
break;
case NUM_KEY_F_MODE:
if (keymap == keymap_normal) {
keymap = keymap_f_mode;
goto retry;
}
break;
case NUM_KEY_CAPS_LOCK:
caps_lock_pressed = 1;
break;
}
} else {
if (key_index < sizeof keyboard_keys) {
keyboard_keys[key_index++] = mapped;
}
}
}
buf >>= 1;
}
}
}
#if !defined(DEBUG)
usb_keyboard_send();
#endif
{
// Process caps lock key. This key is a switch on the Symbolics
// keyboard, so we must make sure that the current switch setting
// always matches the caps lock state of the host.
// If the host set LED 2, it indicates that caps lock has been
// pressed. If the caps lock state reported by the host does not
// match the caps lock key state of the Symbolics keyboard, send a
// "caps lock" key press and release to the host to make the two
// match. As a result, if caps lock is depressed on another
// keyboard connected to the host, it will quickly be cleared
// again.
uint8_t prev_caps_lock_pressed = (keyboard_leds & 2) ? 1 : 0;
if (caps_lock_pressed ^ prev_caps_lock_pressed) {
usb_keyboard_press(KEY_CAPS_LOCK, 0);
}
}
}
int main(void)
{
uint8_t values[3];
uint8_t i;
uint8_t temp;
// set for 16 MHz clock
CPU_PRESCALE(0);
// Configure all port B and port D pins as inputs with pullup resistors
// See the "Using I/O Pins" page for details.
// http://www.pjrc.com/teensy/pins.html
//DDRD
DDRD = 0x00;
DDRB = 0x00;
PORTB = 0xFF;
PORTD = 0xFF;
DDRE=0x00;
PORTE=0xFF;
//set left/right pins to output low
if (left_out.port==OUTPUT_E)
{
DDRE|=left_out.pin;
PORTE&=~left_out.pin;
}
else
{//wtf
}
if (right_out.port==OUTPUT_E)
{
DDRE|=right_out.pin;
PORTE&=~right_out.pin;
}
else
{//wtf
}
// Initialize the USB, and then wait for the host to set configuration.
// If the Teensy is powered without a PC connected to the USB port,
// this will wait forever.
usb_init();
while (!usb_configured()) /* wait */ ;
// Wait an extra second for the PC's operating system to load drivers
// and do whatever it does to actually be ready for input
_delay_ms(1000);
// Initialize the keyboard state to nothing pressed.
keyboard_modifier_keys = 0;
for (i=0; i < 5; i++)
keyboard_keys[i] = 0;
while (1) {
// read all port B and port D pins
values[0] = PINB;
values[1] = PIND;
values[2] = PORTE;
for (i=0; i<NUM_BUTTONS; i++)
{
// Shift the debounce value for this button to the left one bit
debounce[i] <<= 1;
if (values[keyPort[i]] & keyMask[i])
{
// Because we're using a pullup resistor, the value of the pin will be high
// if the button doesn't tie the pin to ground. So set the bottom bit to 1
debounce[i] |= 1;
} else {
// Because we're using a pullup resistor, the value of the pin will be low
// if the button is pressed and ties the pin to ground. So set the bottom bit to 0
debounce[i] &= 0xFE;
}
// If the key has been pressed down for eight loop iterations (8 bits in a byte), send the keydown.
if (debounce[i] == 0x00)
{
// Set key down
keyboard_keys[keyIndex[i]] = key[i];
//turn on IO pin for left/right down
if (key[i]==KEY_S) {//left
values[left_out.port]|=left_out.pin;
}
if (key[i]==KEY_F) {//right
values[right_out.port]|=right_out.pin;
}
} else {
// If the key has been released for eight loop iterations, send keyup (if this key is currently marked as down)
if (debounce[i] == 0xFF)
{
// Set key up
if (keyboard_keys[keyIndex[i]] == key[i])
keyboard_keys[keyIndex[i]] = 0;
//turn off IO pin for left/right down
if (key[i]==KEY_S) {//left
values[left_out.port]&=~left_out.pin;
}
if (key[i]==KEY_F) {//right
values[right_out.port]&=~right_out.pin;
}
}
}
}
//set output ports to updated values
PORTE=values[2];
// Send keyboard_keys and keyboard_modifier_keys to host pc
usb_keyboard_send();
}
}
int main(void) {
kb_init(); // does controller initialization too
kb_led_state_power_on();
usb_init();
while (!usb_configured());
kb_led_delay_usb_init(); // give the OS time to load drivers, etc.
kb_led_state_ready();
for (;;) {
static uint8_t current_layer = 0;
// swap `kb_is_pressed` and `kb_was_pressed`, then update
bool (*temp)[KB_ROWS][KB_COLUMNS] = kb_was_pressed;
kb_was_pressed = kb_is_pressed;
kb_is_pressed = temp;
kb_update_matrix(*kb_is_pressed);
// call the appropriate function for each key, then send the usb report
// if necessary
// - everything else is the key function's responsibility; see the
// keyboard layout file ("keyboard/ergodox/layout/*.c") for which key
// is assigned which function (per layer), and "lib/key-functions.c"
// for their definitions
for (uint8_t row=0; row<KB_ROWS; row++) {
for (uint8_t col=0; col<KB_COLUMNS; col++) {
bool is_pressed = (*kb_is_pressed)[row][col];
bool was_pressed = (*kb_was_pressed)[row][col];
if (is_pressed != was_pressed) {
if (is_pressed) {
kbfun_funptr_t press_function =
kb_layout_press_get(current_layer, row, col);
if (press_function) {
(*press_function)(
kb_layout_get(current_layer, row, col),
¤t_layer, &row, &col );
}
} else {
kbfun_funptr_t release_function =
kb_layout_release_get(current_layer, row, col);
if (release_function) {
(*release_function)(
kb_layout_get(current_layer, row, col),
¤t_layer, &row, &col );
}
}
usb_keyboard_send();
_delay_ms(KB_DEBOUNCE_TIME);
}
}
}
// update LEDs
if (keyboard_leds & (1<<0)) { kb_led_num_on(); }
else { kb_led_num_off(); }
if (keyboard_leds & (1<<1)) { kb_led_caps_on(); }
else { kb_led_caps_off(); }
if (keyboard_leds & (1<<2)) { kb_led_scroll_on(); }
else { kb_led_scroll_off(); }
if (keyboard_leds & (1<<3)) { kb_led_compose_on(); }
else { kb_led_compose_off(); }
if (keyboard_leds & (1<<4)) { kb_led_kana_on(); }
else { kb_led_kana_off(); }
}
return 0;
}
int main()
{
// set for 16 MHz clock
CPU_PRESCALE(0);
// Configure all port B and port D pins as inputs with pullup resistors.
DDRD = 0x00;
DDRB = 0x00;
PORTB = 0xFF;
PORTD = 0xFF;
// Turn the LED on during the configuration
LED_CONFIG;
LED_ON;
// Initialize the USB, and then wait for the host to set configuration.
usb_init();
while (!usb_configured());
// Initialize the gamepad interface
gamepad_init();
// Wait an extra second for the PC's operating system to load drivers
// and do whatever it does to actually be ready for input
_delay_ms(1000);
// Timer 0 configuration (~60Hz)
TCCR0A = 0x00; // Normal mode
TCCR0B = 0x05; // Clock/1024
TIMSK0 = (1<<TOIE0);
LED_OFF;
while (1) {
while (!ready); // Block until the next cycle (~60Hz)
cli();
ready = 0;
sei();
// Read pressed buttons from gamepad interface
gamepad_read();
// Reset key array
reset_keys();
// Special functions
// - Software reboot
if (PRESSED_REBOOT) {
reboot();
}
// 6 keys can be sent at a time, with any number of modifiers.
//
// - Buttons A, B, X and Y have their own position in the key array.
// - Up/down and left/right pairs share one position, as they are
// mutually exclusive (you cannot pres up AND down).
// - L and R use the left and right Shift modifiers.
// - Select and Start use the left and right Ctrl modifiers.
if (PRESSED_A) press_key(KEY_Z, 0);
if (PRESSED_B) press_key(KEY_X, 1);
if (PRESSED_X) press_key(KEY_A, 2);
if (PRESSED_Y) press_key(KEY_S, 3);
if (PRESSED_UP) {
press_key(KEY_UP, 4);
} else if (PRESSED_DOWN){
press_key(KEY_DOWN, 4);
}
if (PRESSED_LEFT) {
press_key(KEY_LEFT, 5);
} else if (PRESSED_RIGHT){
press_key(KEY_RIGHT, 5);
}
if (PRESSED_L) press_modifier(KEY_LEFT_SHIFT);
if (PRESSED_R) press_modifier(KEY_RIGHT_SHIFT);
if (PRESSED_SELECT) press_modifier(KEY_LEFT_CTRL);
if (PRESSED_START) press_modifier(KEY_RIGHT_CTRL);
usb_keyboard_send();
}
}
//Main Program
int main(void)
{
#include "mappings.c"
uint8_t b_prev=0xFF, c_prev=0xFF, d_prev=0xFF;
// set for 16 MHz clock
CLKPR = 0x80, CLKPR = 0;
// Configure all ports as inputs with pullup resistors.
DDRB = 0x00;
DDRC = 0x00;
DDRD = 0x60; // D5,D6 - OUTPUT (LED)
PORTB = 0xFF;
PORTC = 0xFF;
PORTD = 0xFF;
//Initialise LED timings (added v1.1)
clock_prescale_set(clock_div_1);
MCUSR &= ~(1 << WDRF);
wdt_disable();
// Initialize the USB
usb_init();
//flash them leds
#include "../shared/disco.c"
while(!usb_configured());
// // Wait for host to load drivers
// _delay_ms(500);
while(1) {
uint8_t b = PINB;
uint8_t c = PINC;
uint8_t d = PIND;
keycount = 0;
//down
if((!(c & 0x40))&&((c_prev & 0x40))) { keyboard_keys[keycount++] = map[17]; } //PIN B8
if((!(c & 0x80))&&((c_prev & 0x80))) { keyboard_keys[keycount++] = map[16]; } //PIN B7
if((!(b & 0x80))&&((b_prev & 0x80))) { keyboard_keys[keycount++] = map[15]; } //PIN B6
if((!(b & 0x40))&&((b_prev & 0x40))) { keyboard_keys[keycount++] = map[14]; } //PIN B5
if((!(b & 0x20))&&((b_prev & 0x20))) { keyboard_keys[keycount++] = map[13]; } //PIN B4
if((!(b & 0x10))&&((b_prev & 0x10))) { keyboard_keys[keycount++] = map[12]; } //PIN B3
if((!(b & 0x08))&&((b_prev & 0x08))) { keyboard_keys[keycount++] = map[11]; } //PIN B2
if((!(b & 0x04))&&((b_prev & 0x04))) { keyboard_keys[keycount++] = map[10]; } //PIN B1
if((!(d & 0x04))&&((d_prev & 0x04))) { keyboard_keys[keycount++] = map[3]; } //PIN A4
if((!(d & 0x02))&&((d_prev & 0x02))) { keyboard_keys[keycount++] = map[2]; } //PIN A3
if((!(d & 0x01))&&((d_prev & 0x01))) { keyboard_keys[keycount++] = map[1]; } //PIN A2
if((!(c & 0x04))&&((c_prev & 0x04))) { keyboard_keys[keycount++] = map[0]; } //PIN A1
//up
if(((c & 0x40))&&(!(c_prev & 0x40))) { keyboard_keys[keycount++] = map[37]; } //PIN B8
if(((c & 0x80))&&(!(c_prev & 0x80))) { keyboard_keys[keycount++] = map[36]; } //PIN B7
if(((b & 0x80))&&(!(b_prev & 0x80))) { keyboard_keys[keycount++] = map[35]; } //PIN B6
if(((b & 0x40))&&(!(b_prev & 0x40))) { keyboard_keys[keycount++] = map[34]; } //PIN B5
if(((b & 0x20))&&(!(b_prev & 0x20))) { keyboard_keys[keycount++] = map[33]; } //PIN B4
if(((b & 0x10))&&(!(b_prev & 0x10))) { keyboard_keys[keycount++] = map[32]; } //PIN B3
if(((b & 0x08))&&(!(b_prev & 0x08))) { keyboard_keys[keycount++] = map[31]; } //PIN B2
if(((b & 0x04))&&(!(b_prev & 0x04))) { keyboard_keys[keycount++] = map[30]; } //PIN B1
if(((d & 0x04))&&(!(d_prev & 0x04))) { keyboard_keys[keycount++] = map[23]; } //PIN A4
if(((d & 0x02))&&(!(d_prev & 0x02))) { keyboard_keys[keycount++] = map[22]; } //PIN A3
if(((d & 0x01))&&(!(d_prev & 0x01))) { keyboard_keys[keycount++] = map[21]; } //PIN A2
if(((c & 0x04))&&(!(c_prev & 0x04))) { keyboard_keys[keycount++] = map[20]; } //PIN A1
while(keycount < sizeof(keyboard_keys)) {
keyboard_keys[keycount++] = KEY_NONE;
}
usb_keyboard_send();
b_prev = b;
c_prev = c;
d_prev = d;
_delay_ms(10); // Debounce
}
}
int main(void)
{
uint8_t b, d, mask, i, reset_idle;
uint8_t b_prev=0xFF;
// set for 16 MHz clock
CPU_PRESCALE(0);
// Configure all port B and port D pins as inputs with pullup resistors.
// See the "Using I/O Pins" page for details.
// http://www.pjrc.com/teensy/pins.html
DDRB = 0x00;
PORTB = 0xFF;
DDRD = 0xFF;
PORTD = 0x00;
// Initialize the USB, and then wait for the host to set configuration.
// If the Teensy is powered without a PC connected to the USB port,
// this will wait forever.
usb_init();
while (!usb_configured()) /* wait */ ;
// Wait an extra second for the PC's operating system to load drivers
// and do whatever it does to actually be ready for input
_delay_ms(1000);
// Check if the last two switches are already shorted:
// read all port B pins
b = PINB;
// check if any pins are low, if so mark them as shorted (0), if they are still high, mark them as open (1)
for (i=0; i<sizeof(pns); i++) {
if (((b & pns[i]) == 0)) {
pnsActive[i] = 0;
} else {
pnsActive[i] = 1;
}
}
// for ports that are active (not shorted) on B, light corresponding LEDs on D
for (i=0; i<sizeof(pns); i++) {
if (pnsActive[i] == 0) {
PORTD &= ~(pns[i]);
} else {
PORTD |= (pns[i]);
}
}
while (1) {
// read all port B pins
b = PINB;
// if the pins were not shorted on boot, check if any pins are low, but were high previously
for (i=0; i<sizeof(pns); i++) {
if (pnsActive[i] && (((b & pns[i]) == 0) && (b_prev & pns[i]) != 0)) {
// usb_keyboard_press(buttons[i], 0);
keyboard_modifier_keys = 0;
keyboard_keys[0] = buttons[i];
usb_keyboard_send();
_delay_ms(10);
keyboard_keys[0] = 0;
usb_keyboard_send(); }
}
// now the current pins will be the previous, and
// wait a short delay so we're not highly sensitive
// to mechanical "bounce".
b_prev = b;
_delay_ms(2);
}
}
/*
* main()
*/
int main(void) {
kb_init(); // does controller initialization too
kb_led_state_power_on();
usb_init();
while (!usb_configured());
kb_led_delay_usb_init(); // give the OS time to load drivers, etc.
kb_led_state_ready();
for (;;) {
// swap `main_kb_is_pressed` and `main_kb_was_pressed`, then update
bool (*temp)[KB_ROWS][KB_COLUMNS] = main_kb_was_pressed;
main_kb_was_pressed = main_kb_is_pressed;
main_kb_is_pressed = temp;
kb_update_matrix(*main_kb_is_pressed);
// this loop is responsible to
// - "execute" keys when they change state
// - keep track of which layers the keys were on when they were pressed
// (so they can be released using the function from that layer)
//
// note
// - everything else is the key function's responsibility
// - see the keyboard layout file ("keyboard/ergodox/layout/*.c") for
// which key is assigned which function (per layer)
// - see "lib/key-functions/public/*.c" for the function definitions
#define row main_loop_row
#define col main_loop_col
#define layer main_arg_layer
#define is_pressed main_arg_is_pressed
#define was_pressed main_arg_was_pressed
for (row=0; row<KB_ROWS; row++) {
for (col=0; col<KB_COLUMNS; col++) {
is_pressed = (*main_kb_is_pressed)[row][col];
was_pressed = (*main_kb_was_pressed)[row][col];
if (is_pressed != was_pressed) {
if (is_pressed) {
layer = main_layers_peek(0);
main_layers_pressed[row][col] = layer;
main_arg_trans_key_pressed = false;
} else {
layer = main_layers_pressed[row][col];
main_arg_trans_key_pressed = main_kb_was_transparent[row][col];
}
// set remaining vars, and "execute" key
main_arg_row = row;
main_arg_col = col;
main_arg_layer_offset = 0;
main_exec_key();
main_kb_was_transparent[row][col] = main_arg_trans_key_pressed;
}
}
}
#undef row
#undef col
#undef layer
#undef is_pressed
#undef was_pressed
// send the USB report (even if nothing's changed)
usb_keyboard_send();
usb_extra_consumer_send();
_delay_ms(MAKEFILE_DEBOUNCE_TIME);
// update LEDs
/*if (keyboard_leds & (1<<0)) { kb_led_num_on(); }*/
/*else { kb_led_num_off(); }*/
if (keyboard_leds & (1<<1)) { kb_led_caps_on(); }
else { kb_led_caps_off(); }
if (keyboard_leds & (1<<2)) { kb_led_scroll_on(); }
else { kb_led_scroll_off(); }
if (keyboard_leds & (1<<3)) { kb_led_compose_on(); }
else { kb_led_compose_off(); }
if (keyboard_leds & (1<<4)) { kb_led_kana_on(); }
else { kb_led_kana_off(); }
if (layers_head != 0) { kb_led_num_on(); }
else { kb_led_num_off(); }
}
return 0;
}
static inline void numpad_toggle_numlock(void) {
_kbfun_press_release(true, KEY_LockingNumLock);
usb_keyboard_send();
_kbfun_press_release(false, KEY_LockingNumLock);
usb_keyboard_send();
}
