good enough for a preview

keyboard/preonic/Makefile

@@ -126,6 +126,10 @@ BACKLIGHT_ENABLE = yes  # Enable keyboard backlight functionality
 MIDI_ENABLE = yes 		# MIDI controls
 BACKLIGHT_ENABLE = yes
 
+ifdef MIDI_ENABLE
+	SRC += keymap_midi.c
+endif
+
 # Optimize size but this may cause error "relocation truncated to fit"
 #EXTRALDFLAGS = -Wl,--relax
 

keyboard/preonic/config.h

@@ -22,7 +22,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 /* USB Device descriptor parameter */
 #define VENDOR_ID       0xFEED
-#define PRODUCT_ID      0x6060
+#define PRODUCT_ID      0x6062
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    Ortholinear Keyboards
 #define PRODUCT         The Preonic Keyboard

keyboard/preonic/extended_keymap_common.c

@@ -23,10 +23,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "action_macro.h"
 #include "debug.h"
 #include "backlight.h"
+#include "keymap_midi.h"
+#include <lufa.h>
 
 static action_t keycode_to_action(uint16_t keycode);
 
-
 /* converts key to action */
 action_t action_for_key(uint8_t layer, keypos_t key)
 {
@@ -69,9 +70,14 @@ action_t action_for_key(uint8_t layer, keypos_t key)
     } else if (keycode == RESET) {
         bootloader_jump();
         return;
-    } else if (keycode > RESET) {
+    } else if (keycode == DEBUG) {
-        // MIDI
+        print("\nDEBUG: enabled.\n");
+        debug_enable = true;
         return;
+    } else if (keycode >= 0x6000 && keycode < 0x7000) {
+        action_t action;
+        action.code =  ACTION_FUNCTION_OPT(keycode & 0xFF, (keycode & 0x0F00) >> 8);
+        return action;
     }
 
     switch (keycode) {

keyboard/preonic/extended_keymap_common.h

@@ -174,6 +174,7 @@ extern const uint16_t fn_actions[];
 #define BL_STEP 0x4013
 
 #define RESET 0x5000
+#define DEBUG 0x5001
 
 #define MIDI(n) n | 0x6000
 

keyboard/preonic/extended_keymaps/extended_keymap_lock.c

@@ -2,10 +2,11 @@
 #include "backlight.h"
 #include "action_layer.h"
 #include "lufa.h"
+#include "keymap_midi.h"
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [0] = { /* Qwerty */
-  {KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,   KC_DEL},
+  {KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,   KC_BSPC},
   {KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,   KC_BSPC},
   {KC_ESC,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN,  KC_QUOT},
   {KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT},
@@ -13,33 +14,41 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                                                 // Space is repeated to accommadate for both spacebar wiring positions
 },
 [1] = { /* Colemak */
-  {KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,   KC_DEL},
+  {KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,   KC_BSPC},
   {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_DEL},
+  {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_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_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,  FUNC(1),   KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
 },
 [3] = { /* LOWER */
-  {KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,   KC_DEL},
+  {KC_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},
   {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), 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}
 },
 [4] = { /* TENKEY */
-  {KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,   KC_DEL},
+  {KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,   KC_BSPC},
   {KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_KP_7,    KC_KP_8,    KC_KP_9,    KC_P,   KC_BSPC},
   {KC_ESC,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_KP_4,    KC_KP_5,    KC_KP_6,    KC_SCLN,  KC_QUOT},
   {KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_KP_1,    KC_KP_2,    KC_KP_3,  KC_SLSH, KC_ENT},
   {KC_TRNS, KC_LCTL, KC_LALT, KC_LGUI, KC_TRNS,    KC_SPC,   KC_SPC, KC_KP_0,   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+},
+[5] = {
+  { MIDI12 },
+  { MIDI12 },
+  { MIDI12 },
+  { MIDI12 },
+  {M(0), KC_LCTL, KC_LALT, KC_LGUI, FUNC(2),    KC_SPC,   KC_SPC,    FUNC(1),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
 }
+
 };
 
 const uint16_t PROGMEM fn_actions[] = {
@@ -53,19 +62,18 @@ 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:   
         if (record->event.pressed) {
           // register_code(KC_RSFT);
           backlight_set(BACKLIGHT_LEVELS);
-          midi_send_noteon(&midi_device, 1, 64, 127);
+          default_layer_and(0); 
-          layer_on(4);
+          default_layer_or((1<<5));
         } else {
           // unregister_code(KC_RSFT);
           backlight_set(0);
-          midi_send_noteoff(&midi_device, 1, 64, 127);
+          default_layer_and(0); 
-          layer_clear();
+          default_layer_or(0);
         }
         break;
       } 

keyboard/preonic/keymap_midi.c

@@ -0,0 +1,56 @@
+/*
+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 "extended_keymap_common.h"
+#include "keymap_midi.h"
+#include <lufa.h>
+
+uint8_t starting_note = 0x0C;
+
+void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+	if (id != 0) {
+	    if (record->event.pressed) {
+	    	midi_send_noteon(&midi_device, opt, (id & 0xFF), 127);
+	    } else {
+	        midi_send_noteoff(&midi_device, opt, (id & 0xFF), 127);
+	    }
+	}
+
+    if (record->event.key.col == 11 && record->event.key.row == 4) {
+        starting_note++;
+        midi_send_cc(&midi_device, 0, 0x7B, 0);
+        midi_send_cc(&midi_device, 1, 0x7B, 0);
+        midi_send_cc(&midi_device, 2, 0x7B, 0);
+        midi_send_cc(&midi_device, 3, 0x7B, 0);
+        midi_send_cc(&midi_device, 4, 0x7B, 0);
+    }
+    if (record->event.key.col == 8 && record->event.key.row == 4) {
+        starting_note--;
+        midi_send_cc(&midi_device, 0, 0x7B, 0);
+        midi_send_cc(&midi_device, 1, 0x7B, 0);
+        midi_send_cc(&midi_device, 2, 0x7B, 0);
+        midi_send_cc(&midi_device, 3, 0x7B, 0);
+        midi_send_cc(&midi_device, 4, 0x7B, 0);
+    }
+
+    if (record->event.pressed) {
+    	midi_send_noteon(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
+    } else {
+        midi_send_noteoff(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
+    }
+}

keyboard/preonic/keymap_midi.h

@@ -0,0 +1,216 @@
+/*
+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/>.
+*/
+
+#ifndef KEYMAP_MIDI_H
+#define KEYMAP_MIDI_H
+
+#define MIDI 0x6000
+#define MIDI12 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000
+
+#define CHNL(note, channel) (note + (channel << 8))
+
+#define SCALE (int []){ 0, 2, 4, 5, 7, 9, 11, 12, 14, 16, 17, 19, 21, 23, 24, 26, 28, 29, 31, 33, 35, 36}
+
+#define N_CN1  (0x600C + (12 * -1) + 0 )
+#define N_CN1S (0x600C + (12 * -1) + 1 )
+#define N_DN1F (0x600C + (12 * -1) + 1 )
+#define N_DN1  (0x600C + (12 * -1) + 2 )
+#define N_DN1S (0x600C + (12 * -1) + 3 )
+#define N_EN1F (0x600C + (12 * -1) + 3 )
+#define N_EN1  (0x600C + (12 * -1) + 4 )
+#define N_FN1  (0x600C + (12 * -1) + 5 )
+#define N_FN1S (0x600C + (12 * -1) + 6 )
+#define N_GN1F (0x600C + (12 * -1) + 6 )
+#define N_GN1  (0x600C + (12 * -1) + 7 )
+#define N_GN1S (0x600C + (12 * -1) + 8 )
+#define N_AN1F (0x600C + (12 * -1) + 8 )
+#define N_AN1  (0x600C + (12 * -1) + 9 )
+#define N_AN1S (0x600C + (12 * -1) + 10)
+#define N_BN1F (0x600C + (12 * -1) + 10)
+#define N_BN1  (0x600C + (12 * -1) + 11)
+#define N_C0   (0x600C + (12 *  0) + 0 )
+#define N_C0S  (0x600C + (12 *  0) + 1 )
+#define N_D0F  (0x600C + (12 *  0) + 1 )
+#define N_D0   (0x600C + (12 *  0) + 2 )
+#define N_D0S  (0x600C + (12 *  0) + 3 )
+#define N_E0F  (0x600C + (12 *  0) + 3 )
+#define N_E0   (0x600C + (12 *  0) + 4 )
+#define N_F0   (0x600C + (12 *  0) + 5 )
+#define N_F0S  (0x600C + (12 *  0) + 6 )
+#define N_G0F  (0x600C + (12 *  0) + 6 )
+#define N_G0   (0x600C + (12 *  0) + 7 )
+#define N_G0S  (0x600C + (12 *  0) + 8 )
+#define N_A0F  (0x600C + (12 *  0) + 8 )
+#define N_A0   (0x600C + (12 *  0) + 9 )
+#define N_A0S  (0x600C + (12 *  0) + 10)
+#define N_B0F  (0x600C + (12 *  0) + 10)
+#define N_B0   (0x600C + (12 *  0) + 11)
+#define N_C1   (0x600C + (12 *  1) + 0 )
+#define N_C1S  (0x600C + (12 *  1) + 1 )
+#define N_D1F  (0x600C + (12 *  1) + 1 )
+#define N_D1   (0x600C + (12 *  1) + 2 )
+#define N_D1S  (0x600C + (12 *  1) + 3 )
+#define N_E1F  (0x600C + (12 *  1) + 3 )
+#define N_E1   (0x600C + (12 *  1) + 4 )
+#define N_F1   (0x600C + (12 *  1) + 5 )
+#define N_F1S  (0x600C + (12 *  1) + 6 )
+#define N_G1F  (0x600C + (12 *  1) + 6 )
+#define N_G1   (0x600C + (12 *  1) + 7 )
+#define N_G1S  (0x600C + (12 *  1) + 8 )
+#define N_A1F  (0x600C + (12 *  1) + 8 )
+#define N_A1   (0x600C + (12 *  1) + 9 )
+#define N_A1S  (0x600C + (12 *  1) + 10)
+#define N_B1F  (0x600C + (12 *  1) + 10)
+#define N_B1   (0x600C + (12 *  1) + 11)
+#define N_C2   (0x600C + (12 *  2) + 0 )
+#define N_C2S  (0x600C + (12 *  2) + 1 )
+#define N_D2F  (0x600C + (12 *  2) + 1 )
+#define N_D2   (0x600C + (12 *  2) + 2 )
+#define N_D2S  (0x600C + (12 *  2) + 3 )
+#define N_E2F  (0x600C + (12 *  2) + 3 )
+#define N_E2   (0x600C + (12 *  2) + 4 )
+#define N_F2   (0x600C + (12 *  2) + 5 )
+#define N_F2S  (0x600C + (12 *  2) + 6 )
+#define N_G2F  (0x600C + (12 *  2) + 6 )
+#define N_G2   (0x600C + (12 *  2) + 7 )
+#define N_G2S  (0x600C + (12 *  2) + 8 )
+#define N_A2F  (0x600C + (12 *  2) + 8 )
+#define N_A2   (0x600C + (12 *  2) + 9 )
+#define N_A2S  (0x600C + (12 *  2) + 10)
+#define N_B2F  (0x600C + (12 *  2) + 10)
+#define N_B2   (0x600C + (12 *  2) + 11)
+#define N_C3   (0x600C + (12 *  3) + 0 )
+#define N_C3S  (0x600C + (12 *  3) + 1 )
+#define N_D3F  (0x600C + (12 *  3) + 1 )
+#define N_D3   (0x600C + (12 *  3) + 2 )
+#define N_D3S  (0x600C + (12 *  3) + 3 )
+#define N_E3F  (0x600C + (12 *  3) + 3 )
+#define N_E3   (0x600C + (12 *  3) + 4 )
+#define N_F3   (0x600C + (12 *  3) + 5 )
+#define N_F3S  (0x600C + (12 *  3) + 6 )
+#define N_G3F  (0x600C + (12 *  3) + 6 )
+#define N_G3   (0x600C + (12 *  3) + 7 )
+#define N_G3S  (0x600C + (12 *  3) + 8 )
+#define N_A3F  (0x600C + (12 *  3) + 8 )
+#define N_A3   (0x600C + (12 *  3) + 9 )
+#define N_A3S  (0x600C + (12 *  3) + 10)
+#define N_B3F  (0x600C + (12 *  3) + 10)
+#define N_B3   (0x600C + (12 *  3) + 11)
+#define N_C4   (0x600C + (12 *  4) + 0 )
+#define N_C4S  (0x600C + (12 *  4) + 1 )
+#define N_D4F  (0x600C + (12 *  4) + 1 )
+#define N_D4   (0x600C + (12 *  4) + 2 )
+#define N_D4S  (0x600C + (12 *  4) + 3 )
+#define N_E4F  (0x600C + (12 *  4) + 3 )
+#define N_E4   (0x600C + (12 *  4) + 4 )
+#define N_F4   (0x600C + (12 *  4) + 5 )
+#define N_F4S  (0x600C + (12 *  4) + 6 )
+#define N_G4F  (0x600C + (12 *  4) + 6 )
+#define N_G4   (0x600C + (12 *  4) + 7 )
+#define N_G4S  (0x600C + (12 *  4) + 8 )
+#define N_A4F  (0x600C + (12 *  4) + 8 )
+#define N_A4   (0x600C + (12 *  4) + 9 )
+#define N_A4S  (0x600C + (12 *  4) + 10)
+#define N_B4F  (0x600C + (12 *  4) + 10)
+#define N_B4   (0x600C + (12 *  4) + 11)
+#define N_C5   (0x600C + (12 *  5) + 0 )
+#define N_C5S  (0x600C + (12 *  5) + 1 )
+#define N_D5F  (0x600C + (12 *  5) + 1 )
+#define N_D5   (0x600C + (12 *  5) + 2 )
+#define N_D5S  (0x600C + (12 *  5) + 3 )
+#define N_E5F  (0x600C + (12 *  5) + 3 )
+#define N_E5   (0x600C + (12 *  5) + 4 )
+#define N_F5   (0x600C + (12 *  5) + 5 )
+#define N_F5S  (0x600C + (12 *  5) + 6 )
+#define N_G5F  (0x600C + (12 *  5) + 6 )
+#define N_G5   (0x600C + (12 *  5) + 7 )
+#define N_G5S  (0x600C + (12 *  5) + 8 )
+#define N_A5F  (0x600C + (12 *  5) + 8 )
+#define N_A5   (0x600C + (12 *  5) + 9 )
+#define N_A5S  (0x600C + (12 *  5) + 10)
+#define N_B5F  (0x600C + (12 *  5) + 10)
+#define N_B5   (0x600C + (12 *  5) + 11)
+#define N_C6   (0x600C + (12 *  6) + 0 )
+#define N_C6S  (0x600C + (12 *  6) + 1 )
+#define N_D6F  (0x600C + (12 *  6) + 1 )
+#define N_D6   (0x600C + (12 *  6) + 2 )
+#define N_D6S  (0x600C + (12 *  6) + 3 )
+#define N_E6F  (0x600C + (12 *  6) + 3 )
+#define N_E6   (0x600C + (12 *  6) + 4 )
+#define N_F6   (0x600C + (12 *  6) + 5 )
+#define N_F6S  (0x600C + (12 *  6) + 6 )
+#define N_G6F  (0x600C + (12 *  6) + 6 )
+#define N_G6   (0x600C + (12 *  6) + 7 )
+#define N_G6S  (0x600C + (12 *  6) + 8 )
+#define N_A6F  (0x600C + (12 *  6) + 8 )
+#define N_A6   (0x600C + (12 *  6) + 9 )
+#define N_A6S  (0x600C + (12 *  6) + 10)
+#define N_B6F  (0x600C + (12 *  6) + 10)
+#define N_B6   (0x600C + (12 *  6) + 11)
+#define N_C7   (0x600C + (12 *  7) + 0 )
+#define N_C7S  (0x600C + (12 *  7) + 1 )
+#define N_D7F  (0x600C + (12 *  7) + 1 )
+#define N_D7   (0x600C + (12 *  7) + 2 )
+#define N_D7S  (0x600C + (12 *  7) + 3 )
+#define N_E7F  (0x600C + (12 *  7) + 3 )
+#define N_E7   (0x600C + (12 *  7) + 4 )
+#define N_F7   (0x600C + (12 *  7) + 5 )
+#define N_F7S  (0x600C + (12 *  7) + 6 )
+#define N_G7F  (0x600C + (12 *  7) + 6 )
+#define N_G7   (0x600C + (12 *  7) + 7 )
+#define N_G7S  (0x600C + (12 *  7) + 8 )
+#define N_A7F  (0x600C + (12 *  7) + 8 )
+#define N_A7   (0x600C + (12 *  7) + 9 )
+#define N_A7S  (0x600C + (12 *  7) + 10)
+#define N_B7F  (0x600C + (12 *  7) + 10)
+#define N_B7   (0x600C + (12 *  7) + 11)
+#define N_C8   (0x600C + (12 *  8) + 0 )
+#define N_C8S  (0x600C + (12 *  8) + 1 )
+#define N_D8F  (0x600C + (12 *  8) + 1 )
+#define N_D8   (0x600C + (12 *  8) + 2 )
+#define N_D8S  (0x600C + (12 *  8) + 3 )
+#define N_E8F  (0x600C + (12 *  8) + 3 )
+#define N_E8   (0x600C + (12 *  8) + 4 )
+#define N_F8   (0x600C + (12 *  8) + 5 )
+#define N_F8S  (0x600C + (12 *  8) + 6 )
+#define N_G8F  (0x600C + (12 *  8) + 6 )
+#define N_G8   (0x600C + (12 *  8) + 7 )
+#define N_G8S  (0x600C + (12 *  8) + 8 )
+#define N_A8F  (0x600C + (12 *  8) + 8 )
+#define N_A8   (0x600C + (12 *  8) + 9 )
+#define N_A8S  (0x600C + (12 *  8) + 10)
+#define N_B8F  (0x600C + (12 *  8) + 10)
+#define N_B8   (0x600C + (12 *  8) + 11)
+#define N_C8   (0x600C + (12 *  8) + 0 )
+#define N_C8S  (0x600C + (12 *  8) + 1 )
+#define N_D8F  (0x600C + (12 *  8) + 1 )
+#define N_D8   (0x600C + (12 *  8) + 2 )
+#define N_D8S  (0x600C + (12 *  8) + 3 )
+#define N_E8F  (0x600C + (12 *  8) + 3 )
+#define N_E8   (0x600C + (12 *  8) + 4 )
+#define N_F8   (0x600C + (12 *  8) + 5 )
+#define N_F8S  (0x600C + (12 *  8) + 6 )
+#define N_G8F  (0x600C + (12 *  8) + 6 )
+#define N_G8   (0x600C + (12 *  8) + 7 )
+#define N_G8S  (0x600C + (12 *  8) + 8 )
+#define N_A8F  (0x600C + (12 *  8) + 8 )
+#define N_A8   (0x600C + (12 *  8) + 9 )
+#define N_A8S  (0x600C + (12 *  8) + 10)
+#define N_B8F  (0x600C + (12 *  8) + 10)
+#define N_B8   (0x600C + (12 *  8) + 11)
+
+#endif