From 6ec03b22187fb3c16677c4c0583e66d6d6a5c4f1 Mon Sep 17 00:00:00 2001
From: Jack Humbert <jack.humb@gmail.com>
Date: Mon, 14 Sep 2015 23:54:49 -0400
Subject: unicode working, i think

---
 keyboard/planck/Makefile                |   7 +-
 keyboard/planck/keymap_common.c         |  15 ++
 keyboard/planck/keymap_common.h         |   4 +-
 keyboard/planck/keymap_unicode.c        |  49 +++++++
 keyboard/planck/keymaps/keymap_monkey.c |  76 +++++++++++
 keyboard/planck/matrix_steno.c          | 234 ++++++++++++++++++++++++++++++++
 6 files changed, 383 insertions(+), 2 deletions(-)
 create mode 100644 keyboard/planck/keymap_unicode.c
 create mode 100644 keyboard/planck/keymaps/keymap_monkey.c
 create mode 100644 keyboard/planck/matrix_steno.c

diff --git a/keyboard/planck/Makefile b/keyboard/planck/Makefile
index ad0c824375..3ac20a55a4 100644
--- a/keyboard/planck/Makefile
+++ b/keyboard/planck/Makefile
@@ -125,13 +125,18 @@ COMMAND_ENABLE = yes    # Commands for debug and configuration
 #SLEEP_LED_ENABLE = yes  # Breathing sleep LED during USB suspend
 # NKRO_ENABLE = yes		# USB Nkey Rollover - not yet supported in LUFA
 BACKLIGHT_ENABLE = yes  # Enable keyboard backlight functionality
-MIDI_ENABLE = YES 		# MIDI controls
+# MIDI_ENABLE = YES 		# MIDI controls
+UNICODE_ENABLE = YES 		# MIDI controls
 BACKLIGHT_ENABLE = yes
 
 ifdef MIDI_ENABLE
 	SRC += keymap_midi.c
 endif
 
+ifdef UNICODE_ENABLE
+	SRC += keymap_unicode.c
+endif
+
 # Optimize size but this may cause error "relocation truncated to fit"
 #EXTRALDFLAGS = -Wl,--relax
 
diff --git a/keyboard/planck/keymap_common.c b/keyboard/planck/keymap_common.c
index 886bfe23c4..dd66391135 100644
--- a/keyboard/planck/keymap_common.c
+++ b/keyboard/planck/keymap_common.c
@@ -28,6 +28,16 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 static action_t keycode_to_action(uint16_t keycode);
 
 
+uint16_t hextokeycode(int hex) {
+    if (hex == 0x0) {
+        return KC_0;
+    } else if (hex < 0xA) {
+        return KC_1 + (hex - 0x1);
+    } else {
+        return KC_A + (hex - 0xA);
+    }
+}
+
 /* converts key to action */
 action_t action_for_key(uint8_t layer, keypos_t key)
 {
@@ -78,6 +88,11 @@ action_t action_for_key(uint8_t layer, keypos_t key)
         action_t action;
         action.code =  ACTION_FUNCTION_OPT(keycode & 0xFF, (keycode & 0x0F00) >> 8);
         return action;
+    } else if (keycode >= 0x8000 && keycode < 0x9000) {
+        action_t action;
+        uint16_t unicode = keycode & ~(0x8000);
+        action.code =  ACTION_FUNCTION_OPT(unicode & 0xFF, (unicode & 0xFF00) >> 8);
+        return action;
     }
 
     switch (keycode) {
diff --git a/keyboard/planck/keymap_common.h b/keyboard/planck/keymap_common.h
index 7ccfa1b039..73df8424a5 100644
--- a/keyboard/planck/keymap_common.h
+++ b/keyboard/planck/keymap_common.h
@@ -176,6 +176,8 @@ extern const uint16_t fn_actions[];
 #define RESET 0x5000
 #define DEBUG 0x5001
 
-#define MIDI(n) n | 0x6000
+#define MIDI(n) (n | 0x6000)
+
+#define UNI(n) (n | 0x8000)
 
 #endif
diff --git a/keyboard/planck/keymap_unicode.c b/keyboard/planck/keymap_unicode.c
new file mode 100644
index 0000000000..8e187d99f5
--- /dev/null
+++ b/keyboard/planck/keymap_unicode.c
@@ -0,0 +1,49 @@
+/*
+Copyright 2015 Jack Humbert <jack.humb@gmail.com>
+
+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
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "keymap_common.h"
+
+void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+
+    if (record->event.pressed) {
+        uint16_t unicode = (opt << 8) | id;
+        register_code(KC_LALT);
+
+        register_code(hextokeycode((unicode & 0xF000) >> 12));
+        unregister_code(hextokeycode((unicode & 0xF000) >> 12));
+        register_code(hextokeycode((unicode & 0x0F00) >> 8));
+        unregister_code(hextokeycode((unicode & 0x0F00) >> 8));
+        register_code(hextokeycode((unicode & 0x00F0) >> 4));
+        unregister_code(hextokeycode((unicode & 0x00F0) >> 4));
+        register_code(hextokeycode((unicode & 0x000F)));
+        unregister_code(hextokeycode((unicode & 0x000F)));
+        
+        /* Test 'a' */
+        // register_code(hextokeycode(0x0));
+        // unregister_code(hextokeycode(0x0));
+        // register_code(hextokeycode(0x0));
+        // unregister_code(hextokeycode(0x0));
+        // register_code(hextokeycode(0x6));
+        // unregister_code(hextokeycode(0x6));
+        // register_code(hextokeycode(0x1));
+        // unregister_code(hextokeycode(0x1));
+
+        unregister_code(KC_LALT);
+    }
+    return;
+}
\ No newline at end of file
diff --git a/keyboard/planck/keymaps/keymap_monkey.c b/keyboard/planck/keymaps/keymap_monkey.c
new file mode 100644
index 0000000000..c0c4534081
--- /dev/null
+++ b/keyboard/planck/keymaps/keymap_monkey.c
@@ -0,0 +1,76 @@
+#include "keymap_common.h"
+#include "backlight.h"
+#include "debug.h"
+
+#define COLEMAK_LAYER 0
+#define QWERTY_LAYER 1
+#define LOWER_LAYER 2
+#define UPPER_LAYER 3
+#define SPACEFN_LAYER 4
+#define TENKEY_LAYER 5
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[COLEMAK_LAYER] = { /* Colemak */
+  {KC_TAB,    UNI(0x0061),     KC_W,    KC_F,    KC_P,    KC_G,     KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN,  KC_BSPC},
+  {KC_LCTL,   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},
+  {FUNC(5),   KC_ESC,   KC_LGUI, KC_LALT, FUNC(1), FUNC(6),  FUNC(6), FUNC(2), KC_LEFT, KC_DOWN, KC_UP,    KC_RGHT}
+},
+[QWERTY_LAYER] = { /* 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_LCTL, 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},
+  {FUNC(5), KC_ESC, KC_LGUI, KC_LALT, FUNC(1), FUNC(6), FUNC(6), FUNC(2), KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
+},
+[LOWER_LAYER] = { /* LOWER */
+  {KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_DELETE},
+  {KC_TRNS, FUNC(3), FUNC(4), RESET,   DEBUG,   KC_TRNS, KC_TRNS, KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_BSLS},
+  {KC_TRNS, 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_HOME, KC_PGDN, KC_PGUP, KC_END}
+},
+[UPPER_LAYER] = { /* RAISE */
+  {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_DELETE},
+  {KC_CALC,   FUNC(3), FUNC(4), RESET,    DEBUG,    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},
+  {KC_TRNS,   KC_TRNS, KC_TRNS, KC_TRNS,  KC_TRNS,  KC_TRNS, KC_TRNS, KC_TRNS,    KC_MNXT,    KC_VOLD,    KC_VOLU,    KC_MPLY}
+},
+[SPACEFN_LAYER] = { /* SpaceFN */
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_UP,   KC_END,   KC_TRNS, KC_TRNS},
+  {KC_TRNS, FUNC(3), FUNC(4), KC_TRNS, KC_TRNS, KC_TRNS, KC_PGUP, KC_LEFT, KC_DOWN, KC_RIGHT, KC_TRNS, KC_TRNS},
+  {KC_TRNS, KC_F11,  KC_F12,  KC_TRNS, KC_TRNS, KC_TRNS, KC_PGDN, 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}
+},
+[TENKEY_LAYER] = { /* TENKEY */
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_KP_7, KC_KP_8, KC_KP_9, KC_PMNS, KC_BSPC},
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_KP_4, KC_KP_5, KC_KP_6, KC_PPLS, KC_NLCK},
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_KP_1, KC_KP_2, KC_KP_3, KC_PDOT, KC_ENT},
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_SPC,  KC_SPC,  KC_KP_0, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS}
+}
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+    [1] = ACTION_LAYER_TAP_KEY(LOWER_LAYER, KC_BSPC),  // Tap for backspace, hold for LOWER
+    [2] = ACTION_LAYER_TAP_KEY(UPPER_LAYER, KC_ENT),  // Tap for enter, hold for RAISE
+
+    [3] = ACTION_DEFAULT_LAYER_SET(COLEMAK_LAYER),
+    [4] = ACTION_DEFAULT_LAYER_SET(QWERTY_LAYER),
+    [5] = ACTION_LAYER_TOGGLE(TENKEY_LAYER),
+    
+    [6] = ACTION_LAYER_TAP_KEY(SPACEFN_LAYER, KC_SPC),  // Tap for space, hold for SpaceFN
+};
+
+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:   
+        if (record->event.pressed) {
+          register_code(KC_RSFT);
+          backlight_step();
+        } else {
+          unregister_code(KC_RSFT);
+        }
+        break;
+      } 
+    return MACRO_NONE;
+};
\ No newline at end of file
diff --git a/keyboard/planck/matrix_steno.c b/keyboard/planck/matrix_steno.c
new file mode 100644
index 0000000000..98ef55ed68
--- /dev/null
+++ b/keyboard/planck/matrix_steno.c
@@ -0,0 +1,234 @@
+/*
+Copyright 2012 Jun Wako 
+Generated by planckkeyboard.com (2014 Jack Humbert)
+
+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
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*
+ * scan matrix
+ */
+#include <stdint.h>
+#include <stdbool.h>
+#include <avr/io.h>
+#include <util/delay.h>
+#include "print.h"
+#include "debug.h"
+#include "util.h"
+#include "matrix.h"
+
+#ifndef DEBOUNCE
+#   define DEBOUNCE 10
+#endif
+static uint8_t debouncing = DEBOUNCE;
+
+/* matrix state(1:on, 0:off) */
+static matrix_row_t matrix[MATRIX_ROWS];
+static matrix_row_t matrix_debouncing[MATRIX_ROWS];
+
+static matrix_row_t read_cols(void);
+static void init_cols(void);
+static void unselect_rows(void);
+static void select_row(uint8_t row);
+
+inline
+uint8_t matrix_rows(void)
+{
+    return MATRIX_ROWS;
+}
+
+inline
+uint8_t matrix_cols(void)
+{
+    return MATRIX_COLS;
+}
+
+void matrix_init(void)
+{
+    // To use PORTF disable JTAG with writing JTD bit twice within four cycles.
+    MCUCR |= (1<<JTD);
+    MCUCR |= (1<<JTD);
+
+    backlight_init_ports();
+
+    // Turn status LED on
+    DDRE |= (1<<6);
+    PORTE |= (1<<6);
+
+    // initialize row and col
+    unselect_rows();
+    init_cols();
+
+    // initialize matrix state: all keys off
+    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
+        matrix[i] = 0;
+        matrix_debouncing[i] = 0;
+    }
+}
+
+
+uint8_t matrix_scan(void)
+{
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+        select_row(i);
+        _delay_us(30);  // without this wait read unstable value.
+        matrix_row_t cols = read_cols();
+        if (matrix_debouncing[i] != cols) {
+            matrix_debouncing[i] = cols;
+            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_ROWS; i++) {
+                matrix[i] = matrix_debouncing[i];
+            }
+        }
+    }
+
+    return 1;
+}
+
+bool matrix_is_modified(void)
+{
+    if (debouncing) return false;
+    return true;
+}
+
+inline
+bool matrix_is_on(uint8_t row, uint8_t col)
+{
+    return (matrix[row] & ((matrix_row_t)1<col));
+}
+
+inline
+matrix_row_t matrix_get_row(uint8_t row)
+{
+    return matrix[row];
+}
+
+void matrix_print(void)
+{
+    print("\nr/c 0123456789ABCDEF\n");
+    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
+        phex(row); print(": ");
+        pbin_reverse16(matrix_get_row(row));
+        print("\n");
+    }
+}
+
+uint8_t matrix_key_count(void)
+{
+    uint8_t count = 0;
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+        count += bitpop16(matrix[i]);
+    }
+    return count;
+}
+
+static void init_cols(void)
+{
+    int B = 0, C = 0, D = 0, E = 0, F = 0;
+    for(int x = 0; x < MATRIX_COLS; x++) { 
+        int col = COLS[x];
+        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;
+    for(int x = 0; x < MATRIX_COLS; x++) {     
+        int col = COLS[x];
+        if ((col & 0xF0) == 0x20) { 
+            result |= (PINB&(1<<(col & 0x0F)) ? 0 : (1<<x)); 
+        } else if ((col & 0xF0) == 0x30) { 
+            result |= (PINC&(1<<(col & 0x0F)) ? 0 : (1<<x)); 
+        } else if ((col & 0xF0) == 0x40) { 
+            result |= (PIND&(1<<(col & 0x0F)) ? 0 : (1<<x)); 
+        } else if ((col & 0xF0) == 0x50) { 
+            result |= (PINE&(1<<(col & 0x0F)) ? 0 : (1<<x)); 
+        } else if ((col & 0xF0) == 0x60) { 
+            result |= (PINF&(1<<(col & 0x0F)) ? 0 : (1<<x)); 
+        } 
+    }
+    return result;
+}
+
+static void unselect_rows(void)
+{
+    int B = 0, C = 0, D = 0, E = 0, F = 0;
+    for(int x = 0; x < MATRIX_ROWS; x++) { 
+        int row = ROWS[x];
+        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)
+{
+    int row_pin = ROWS[row];
+    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));
+    }  
+}
\ No newline at end of file
-- 
cgit v1.2.3