diff --git a/Scan/avr-capsense/scan_loop.c b/Scan/avr-capsense/scan_loop.c
new file mode 100755
index 0000000..7ce472e
--- /dev/null
+++ b/Scan/avr-capsense/scan_loop.c
@@ -0,0 +1,1391 @@
+/* Keyboard example with debug channel, for Teensy USB Development Board
+ * http://www.pjrc.com/teensy/usb_keyboard.html
+ * Copyright (c) 2008 PJRC.COM, LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+#include <avr/interrupt.h>
+#include <util/delay.h>
+#include "usb_keyboard_debug.h"
+#include "print.h"
+
+#define LED_CONFIG	(DDRD |= (1<<6))
+#define LED_ON		(PORTD &= ~(1<<6))
+#define LED_OFF		(PORTD |= (1<<6))
+#define CPU_PRESCALE(n)	(CLKPR = 0x80, CLKPR = (n))
+
+#define THRESHOLD 0x0a
+#define BUMP_THRESHOLD 0x50
+//((THRESHOLD) * 3)
+#define BUMP_REST_US 1200
+
+#define HYST 1
+#define HYST_T 0x10
+
+#define TEST_KEY_STROBE (0x05)
+#define TEST_KEY_MASK (1 << 0)
+
+#define ADHSM 7
+
+/** Whether to use all of D and C, vs using E0, E1 instead of D6, D7,
+ * or alternately all of D, and E0,E1 and C0,..5 */
+//#define ALL_D_C
+//#define SHORT_D
+#define SHORT_C
+
+// rough offset voltage: one diode drop, about 50mV = 0x3ff * 50/3560 = 20
+//#define OFFSET_VOLTAGE 0x14
+#define OFFSET_VOLTAGE 0x28
+
+volatile uint8_t idle_count=1;
+
+uint8_t blink=0;
+
+volatile uint16_t full_av = 0;
+
+#define RIGHT_JUSTIFY 0
+#define LEFT_JUSTIFY (0xff)
+
+// set left or right justification here:
+#define JUSTIFY_ADC RIGHT_JUSTIFY
+
+#define ADLAR_MASK (1 << ADLAR)
+#ifdef JUSTIFY_ADC
+#define ADLAR_BITS ((ADLAR_MASK) & (JUSTIFY_ADC))
+#else // defaults to right justification.
+#define ADLAR_BITS 0
+#endif
+
+
+// full muxmask
+#define FULL_MUX_MASK ((1 << MUX0) | (1 << MUX1) | (1 << MUX2) | (1 << MUX3) | (1 << MUX4))
+
+// F0-f7 pins only muxmask.
+#define MUX_MASK ((1 << MUX0) | (1 << MUX1) | (1 << MUX2))
+
+#define SET_MUX(X) ((ADMUX) = (((ADMUX) & ~(MUX_MASK)) | ((X) & (MUX_MASK))))
+#define SET_FULL_MUX(X) ((ADMUX) = (((ADMUX) & ~(FULL_MUX_MASK)) | ((X) & (FULL_MUX_MASK))))
+
+#define MUX_1_1 0x1e
+#define MUX_GND 0x1f
+
+
+	// set ADC clock prescale
+#define PRESCALE_MASK ((1 << ADPS0) | (1 << ADPS1) | (1 << ADPS2))
+#define PRESCALE_SHIFT (ADPS0)
+#define PRESCALE 3
+
+
+/**/ uint8_t ze_strober = 0;
+
+#ifdef EXTENDED_STROBE
+
+#define STROBE_LINES 18
+
+#else
+
+#define STROBE_LINES 16
+
+#endif
+
+#define STROBE_LINES_XSHIFT 4
+#define STROBE_LINES_MASK 0x0f
+#define MUXES_COUNT 8
+#define MUXES_COUNT_XSHIFT 3
+#define MUXES_MASK 0x7
+
+#define WARMUP_LOOPS ( 1024 )
+
+#define RECOVERY_US 6
+
+#define SAMPLES 10
+int16_t samples [SAMPLES];
+
+//int16_t gsamples [SAMPLES];
+
+#define SAMPLE_OFFSET ((SAMPLES) - MUXES_COUNT)
+//#define SAMPLE_OFFSET 9
+#define STROBE_OFFSET 0
+
+/**/ int16_t adc_mux_averages[MUXES_COUNT];
+/**/ int16_t adc_strobe_averages[STROBE_LINES];
+
+
+/**/ uint8_t cur_keymap[STROBE_LINES];
+// /**/ int8_t last_keymap[STROBE_LINES];
+/**/ uint8_t usb_keymap[STROBE_LINES];
+uint8_t dirty;
+uint8_t unstable;
+uint8_t usb_dirty;
+
+int16_t threshold = THRESHOLD;
+uint16_t tests = 0;
+
+uint8_t col_a=0;
+uint8_t col_b=0;
+uint8_t col_c=0;
+
+uint8_t column=0;
+
+#define KEY_COUNT ((STROBE_LINES) * (MUXES_COUNT))
+
+int16_t keys_averages_acc[KEY_COUNT];
+uint16_t keys_averages[KEY_COUNT];
+
+uint8_t full_samples[KEY_COUNT];
+
+/* viable starting biases for near 0.830V offset. and adc PRESCALE 3
+0017 0016 001B 001A 0016 0016 000F 000E 001B 001E 001E 0018 0017 0015 000E 001D
+001B 001A 0016 0016 000F 000E 001C 001B 001E 0018 0017 0015 000E 001D 0024 001F
+0016 0016 000F 000E 001C 001B 001E 001E 0017 0015 000E 001D 0024 001F 0020 001F
+000F 000E 001C 001B 001E 001E 0018 0017 000E 001D 0024 001F 0020 001F 0020 0017
+001C 001B 001E 001E 0018 0017 0015 000E 0024 001F 0020 001F 0020 0017 0010 001D
+001E 001E 0018 0017 0015 000E 001D 0024 0020 001F 0020 0017 0010 001D 0024 0021
+0018 0017 0015 000E 001D 0024 001F 0020 0020 0017 0010 001D 0024 0021 0021 0021
+0015 000E 001D 0024 001F 0020 001F 0020 0010 001D 0024 0021 0021 0021 0021 0018
+*/
+
+/*** starting bias relative to fixed offset estimate of 820mV (0x50)
+ *   77 69 65 5B 50 4E 4C 45   66 53 4D 49 45 3F 3E 35
+ *   68 54 4F 49 45 40 3F 34   74 66 5F 56 4E 4D 4C 3F
+ *   6D 5D 53 4C 49 46 45 38   6D 5A 53 4E 49 48 45 3E
+ *   6F 5D 56 4E 4B 48 48 3A   6D 5C 54 4E 48 48 45 37
+ *   75 68 5F 57 4F 4D 4C 3F   60 4E 48 41 3C 3C 39 2F
+ *   65 53 4E 49 41 3F 3E 34   65 54 4E 49 43 3F 3E 34
+ *   60 51 4A 45 3F 3E 3C 30   57 4C 45 3E 3B 37 37 2E
+ *   64 4E 48 44 3C 3B 39 2F   5D 4F 48 45 3E 3C 3B 30
+ */
+
+/*volatile*/ uint16_t count = 0;
+
+
+
+/*volatile*/ uint8_t error = 0;
+uint16_t error_data = 0;
+
+void dump(void);
+void dumpkeys(void);
+
+static const uint8_t PROGMEM matrix122F_to_set3[] = {
+0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x84, // (), npenter, np3, (), np+, np9, np*, np-
+0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, // np0, np., np2, np5, np6, np8, numlck, np/
+0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, //
+0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+0x00, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, // 0x50 vanishes - is test key.
+0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, // 0x48 vanishes - else roll back.
+0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40,
+0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
+0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
+0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
+0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+0x01, 0x83, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // 0x02 is replaced with 0x83.
+};
+
+#define LX2FX
+
+static const uint8_t PROGMEM page3_2_USB[133] = {
+0x0,		// 00   00  // no key.
+
+#ifndef LX2FX
+
+0xe3,		// 01       Enl   Help -> windows. (e3)
+0x0,		// 02		// no key.
+0x80,	// 03   A4  ExSel SetUp print, -> paste 7d -> vol up 80
+0x46,	// 04   A3  CrSel       Properties -> copy 7c -> mute 7f-> prt-scrn
+0x29,	// 05   9A  Attn  SysRq // good place fer escape. (29)
+0x47,		// 06   9C  Clear -> kp / 54 -> scroll-lock (47)
+0x3a,		// 07   3A  F1
+0x68,		// 08   68  F13
+0x65,		// 09       Ctrl	// record/pause // -> kb application (65)
+0x74,		// 0A       Copy  Test // play/test -> execute 74 -> kp + 57
+0x75,		// 0B      // no key. help (75) -> kp - 56
+0x48,		// 0C       Pause ErInp erase input. -> cut 7b -> kp * 55 -> pause 48
+
+#else
+
+/*
+0x42,		// 01       L9
+0x0,		// 02		// no key.
+0x3e,		// 03		L5
+0x3c,		// 04		L3
+0x3a,		// 05      	L1
+0x3b,		// 06      	L2
+0x3a,		// 07   3A  F1
+0x68,		// 08   68  F13
+0x43,		// 09      	L10
+0x41,		// 0A      	L8
+0x3f,		// 0B      	L6
+0x3d,		// 0C      	L4
+*/
+0x61,		// 01       L9 -> num 9  0x61
+0x0,		// 02		// no key.
+0x5d,		// 03		L5 -> num 5  0x5d
+0x5b,		// 04		L3 -> num 3  0x5b
+0x59,		// 05      	L1 -> num 1  0x59
+0x5a,		// 06      	L2 -> num 2  0x5a
+0x3a,		// 07   3A  F1
+0x68,		// 08   68  F13
+0x62,		// 09      	L10 -> num 0 0x62
+0x60,		// 0A      	L8 -> num 8 0x60
+0x5e,		// 0B      	L6 -> num 6 0x5e
+0x5c,		// 0C      	L4 -> num 4 0x5c
+#endif
+
+
+0x2b,		// 0D   2B  Tab
+0x29,		// 0E   35  ~ ` -> escape 29
+0x3b,		// 0F   3B  F2
+0x69,		// 10   69  F14
+0xe0,		// 11   E0  Ctrl L
+0xe1,		// 12   E1  Shift L
+0xe1,		// 13   64  left of z. -> l shift e1
+0x39,		// 14   39  Caps Lock
+0x14,		// 15   14  Q
+0x1e,		// 16   1E  ! 1
+0x3c,		// 17   3C  F3
+0x6a,		// 18   6A  F15
+0xe2,		// 19   E2  Alt L
+0x1d,		// 1A   1D  Z
+0x16,		// 1B   16  S
+0x04,		// 1C   04  A
+0x1a,		// 1D   1A  W
+0x1f,		// 1E   1F  @ 2
+0x3d,		// 1F   3D  F4
+0x6b,		// 20   6B  F16
+0x06,		// 21   06  C
+0x1b,		// 22   1B  X
+0x07,		// 23   07  D
+0x08,		// 24   08  E
+0x21,		// 25   21  $ 4
+0x20,		// 26   20  # 3
+0x3e,		// 27   3E  F5
+0x6c,		// 28   6C  F17
+0x2c,		// 29   2C  Space
+0x19,		// 2A   19  V
+0x09,		// 2B   09  F
+0x17,		// 2C   17  T
+0x15,		// 2D   15  R
+0x22,		// 2E   22  % 5
+0x3f,		// 2F   3F  F6
+0x6d,		// 30   6D  F18
+0x11,		// 31   11  N
+0x05,		// 32   05  B
+0x0b,		// 33   0B  H
+0x0a,		// 34   0A  G
+0x1c,		// 35   1C  Y
+0x23,		// 36   23  ^ 6
+0x40,		// 37   40  F7
+0x6e,		// 38   6E  F19
+0xe6,		// 39   E6  Alt R
+0x10,		// 3A   10  M
+0x0d,		// 3B   0D  J
+0x18,		// 3C   18  U
+0x24,		// 3D   24  & 7
+0x25,		// 3E   25  * 8
+0x41,		// 3F   41  F8
+0x6f,		// 40   6F  F20
+0x36,		// 41   36  < ,
+0x0e,		// 42   0E  K
+0x0c,		// 43   0C  I
+0x12,		// 44   12  O
+0x27,		// 45   27  ) 0
+0x26,		// 46   26  ( 9
+0x42,		// 47   42  F9
+0x70,		// 48   70  F21
+0x37,		// 49   37  > .
+0x38,		// 4A   38  ? /
+0x0f,		// 4B   0F  L
+0x33,		// 4C   33  : ;
+0x13,		// 4D   13  P
+0x2d,		// 4E   2D  _ -
+0x43,		// 4F   43  F10
+0x71,		// 50   71  F22
+0xe5,		// 51   87  likely a shift - e.g. kp shift -> e5
+0x34,		// 52   34  " '
+0x31,		// 53      (INT 2) -> keypad enter. 58 -> |/\ (31)
+0x2f,		// 54   2F  { [
+0x2e,		// 55   2E  + =
+0x44,		// 56   44  F11
+0x72,		// 57   72  F23  -> vol up.
+0xe4,		// 58   E4  Ctrl R
+0xe5,		// 59   E5  Shift R
+0x28,		// 5A   28  Enter
+0x30,		// 5B   30  } ]
+0x31,		// 5C   31  | '\'
+0x35,		// 5D   -> kp = 67 -> ~` 35
+0x45,		// 5E   45  F12
+0x73,		// 5F   73  F24 -> vol down.
+0x51,		// 60   51  Down CP
+0x50,		// 61   50  Left CP
+0x51, //0x0,// 62       Rule // centre cp.  //62   48  Pause/Bk
+0x52,		// 63   52  Up CP
+0x4c,		// 64   4C  Del CP
+0x4d,		// 65   4D  End CP
+0x2a,		// 66   2A  Back Space
+0x49,		// 67   49  Ins CP
+0x48,		// 68		// under kp0 => kp 0 (62) 48 -> pause (48)
+0x59,		// 69   59  1 End KP
+0x4f,		// 6A   4F  Right CP
+0x5c,		// 6B   5C  4 Left KP
+0x5f,		// 6C   5F  7 Home KP
+0x4e,		// 6D   4E  PgDn CP
+0x4a,		// 6E   4A  Home CP
+0x4b,		// 6F   4B  PgUp CP
+0x62,		// 70   62  0 Ins KP -> pause (+48) -> kp-0 (62)
+0x63,		// 71   63  . Del KP
+0x5a,		// 72   5A  2 Down KP
+0x5d,		// 73   97  5 KP
+0x5e,		// 74   5E  6 Right KP
+0x60,		// 75   60  8 Up KP
+0x53,		// 76   53  Num Lock
+0x54,		// 77   54  / KP
+0x47,		// 78       Undo // under enter -> scroll-lock 47
+0x58,		// 79   58  Enter KP ->  enter kp
+0x5b,		// 7A   5B  3 PgDn KP
+0x46,		// 7B       (INT 5) // under + -> print screen (46
+0x57,		// 7C   57  + KP
+0x61,		// 7D   61  9 PgUp KP
+0x55,		// 7E   55  * KP
+0x0,		// 7F			no such key?
+0x0,		// 80           no such key
+0x0,		// 81              Paste?
+0x0,		// 82              Find?
+#ifndef LX2FX
+0x81,		// 83   Print Ident -> undo 7a -> vol down 81
+#else
+//0x40,		// 83   L7 (f1) 3a
+0x5f,		// 83   L7 (f1) 3a -> num 7 0x5f
+#endif
+0x56		// 84   56  - KP
+};
+
+void
+_delay_loop(uint8_t __count)
+{
+	__asm__ volatile (
+		"1: dec %0" "\n\t"
+		"brne 1b"
+		: "=r" (__count)
+		: "0" (__count)
+	);
+}
+
+
+void setup_ADC (void) {
+	// disable adc digital pins.
+	DIDR1 |= (1 << AIN0D) | (1<<AIN1D); // set disable on pins 1,0.
+	//DIDR0 = 0xff; // disable all. (port F, usually). - testing w/o disable.
+	DDRF = 0x0;
+	PORTF = 0x0;
+	uint8_t mux = 0 & 0x1f; // 0 == first. // 0x1e = 1.1V ref.
+
+	// 0 = external aref 1,1 = 2.56V internal ref
+	uint8_t aref = ((1 << REFS1) | (1 << REFS0)) & ((1 << REFS1) | (1 << REFS0));
+//	uint8_t adlar = 0xff & (1 << ADLAR); // 1 := left justify bits, 0 := right
+	uint8_t adate = (1 << ADATE) & (1 << ADATE); // trigger enable
+	uint8_t trig = 0 & ((1 << ADTS0) | (1 << ADTS1) | (1 << ADTS2)); // 0 = free running
+	// ps2, ps1 := /64 ( 2^6 ) ps2 := /16 (2^4), ps1 := 4, ps0 :=2, PS1,PS0 := 8 (2^8)
+	uint8_t prescale = ( ((PRESCALE) << PRESCALE_SHIFT) & PRESCALE_MASK ); // 001 == 2^1 == 2
+	uint8_t hispeed = (1 << ADHSM);
+	uint8_t en_mux = (1 << ACME);
+
+	//ADCSRA = (ADCSRA & ~PRESCALES) | ((1 << ADPS1) | (1 << ADPS2)); // 2, 1 := /64 ( 2^6 )
+	//ADCSRA = (ADCSRA & ~PRESCALES) | ((1 << ADPS0) | (1 << ADPS2)); // 2, 0 := /32 ( 2^5 )
+	//ADCSRA = (ADCSRA & ~PRESCALES) | ((1 << ADPS2)); // 2 := /16 ( 2^4 )
+
+	ADCSRA = (1 << ADEN) | prescale; // ADC enable
+
+	// select ref.
+	//ADMUX |= ((1 << REFS1) | (1 << REFS0)); // 2.56 V internal.
+	//ADMUX |= ((1 << REFS0) ); // Vcc with external cap.
+	//ADMUX &= ~((1 << REFS1) | (1 << REFS0)); // 0,0 : aref.
+	ADMUX = aref | mux | ADLAR_BITS;
+
+	// enable MUX
+	// ADCSRB |= (1 << ACME); 	// enable
+	// ADCSRB &= ~(1 << ADEN); // ?
+
+	// select first mux.
+	//ADMUX = (ADMUX & ~MUXES); // start at 000 = ADC0
+
+	// clear adlar to left justify data
+	//ADMUX = ~();
+
+	// set adlar to right justify data
+	//ADMUX |= (1 << ADLAR);
+
+
+	// set free-running
+	ADCSRA |= adate; // trigger enable
+	ADCSRB  = en_mux | hispeed | trig | (ADCSRB & ~((1 << ADTS0) | (1 << ADTS1) | (1 << ADTS2))); // trigger select free running
+
+//	ADCSRA |= (1 << ADATE); // tiggger enable
+
+	ADCSRA |= (1 << ADEN); // ADC enable
+	ADCSRA |= (1 << ADSC); // start conversions q
+
+}
+
+
+#define RECOVERY_CONTROL 1
+
+#define RECOVERY_SOURCE 0
+#define RECOVERY_SINK 2
+#define RECOVERY_MASK 0x03
+
+void recovery(uint8_t on) {
+	DDRB |= (1 << RECOVERY_CONTROL);
+
+	PORTB &= ~(1 << RECOVERY_SINK);    // SINK always zero
+	DDRB &= ~(1 << RECOVERY_SOURCE);  // SOURCE high imp
+
+	if(on) {
+		DDRB |= (1 << RECOVERY_SINK);	// SINK pull
+
+
+		PORTB |= (1 << RECOVERY_CONTROL);
+
+		PORTB |= (1 << RECOVERY_SOURCE); // SOURCE high
+		DDRB |= (1 << RECOVERY_SOURCE);
+	} else {
+		_delay_loop(10);
+		PORTB &= ~(1 << RECOVERY_CONTROL);
+
+		DDRB &= ~(1 << RECOVERY_SOURCE);
+		PORTB &= ~(1 << RECOVERY_SOURCE); // SOURCE low
+		DDRB &= ~(1 << RECOVERY_SINK);	// SINK high-imp
+
+		//DDRB &= ~(1 << RECOVERY_SINK);
+	}
+}
+
+void strobe_w(uint8_t strobe_num) {
+
+#ifdef ALL_D_C
+
+#define D_MASK (0xff)
+#define D_SHIFT 0
+
+#define E_MASK (0x00)
+#define E_SHIFT 0
+
+#define C_MASK (0xff)
+#define C_SHIFT 8
+
+#else
+#if defined(SHORT_D)
+
+#define D_MASK (0x3f)
+#define D_SHIFT 0
+
+#define E_MASK (0x03)
+#define E_SHIFT 6
+
+#define C_MASK (0xff)
+#define C_SHIFT 8
+
+#else
+#if defined(SHORT_C)
+
+#define D_MASK (0xff)
+#define D_SHIFT 0
+
+#define E_MASK (0x03)
+#define E_SHIFT 6
+
+#define C_MASK (0xff)
+#define C_SHIFT 8
+#endif
+#endif
+#endif
+
+
+
+#define STROBE_CASE(SC_CASE, SC_REG_A) case (SC_CASE): PORT##SC_REG_A = \
+	(( (PORT##SC_REG_A) & ~(1 << (SC_CASE - SC_REG_A##_SHIFT)) ) | (1 << (SC_CASE - SC_REG_A##_SHIFT)))
+
+	PORTC &= ~(D_MASK);
+	PORTD &= ~(D_MASK);
+	PORTE &= ~(E_MASK);
+
+#ifdef SHORT_C
+	strobe_num = 15 - strobe_num;
+#endif
+
+	switch(strobe_num) {
+
+	case 0: PORTD |= (1 << 0); break;
+	case 1: PORTD |= (1 << 1); break;
+	case 2: PORTD |= (1 << 2); break;
+	case 3: PORTD |= (1 << 3); break;
+	case 4: PORTD |= (1 << 4); break;
+	case 5: PORTD |= (1 << 5); break;
+
+#ifdef ALL_D
+
+	case 6: PORTD |= (1 << 6); break;
+	case 7: PORTD |= (1 << 7); break;
+
+	case 8:  PORTC |= (1 << 0); break;
+	case 9:  PORTC |= (1 << 1); break;
+	case 10: PORTC |= (1 << 2); break;
+	case 11: PORTC |= (1 << 3); break;
+	case 12: PORTC |= (1 << 4); break;
+	case 13: PORTC |= (1 << 5); break;
+	case 14: PORTC |= (1 << 6); break;
+	case 15: PORTC |= (1 << 7); break;
+
+	case 16: PORTE |= (1 << 0); break;
+	case 17: PORTE |= (1 << 1); break;
+
+#else
+#ifdef SHORT_D
+
+	case 6: PORTE |= (1 << 0); break;
+	case 7: PORTE |= (1 << 1); break;
+
+	case 8:  PORTC |= (1 << 0); break;
+	case 9:  PORTC |= (1 << 1); break;
+	case 10: PORTC |= (1 << 2); break;
+	case 11: PORTC |= (1 << 3); break;
+	case 12: PORTC |= (1 << 4); break;
+	case 13: PORTC |= (1 << 5); break;
+	case 14: PORTC |= (1 << 6); break;
+	case 15: PORTC |= (1 << 7); break;
+
+#else
+#ifdef SHORT_C
+
+	case 6: PORTD |= (1 << 6); break;
+	case 7: PORTD |= (1 << 7); break;
+
+	case 8: PORTE |= (1 << 0); break;
+	case 9: PORTE |= (1 << 1); break;
+
+	case 10:  PORTC |= (1 << 0); break;
+	case 11:  PORTC |= (1 << 1); break;
+	case 12: PORTC |= (1 << 2); break;
+	case 13: PORTC |= (1 << 3); break;
+	case 14: PORTC |= (1 << 4); break;
+	case 15: PORTC |= (1 << 5); break;
+
+	case 16: PORTC |= (1 << 6); break;
+	case 17: PORTC |= (1 << 7); break;
+
+#endif
+#endif
+#endif
+
+	default:
+		break;
+	}
+
+}
+
+
+int sampleColumn_i(uint8_t column, uint8_t muxes, int16_t * buffer) {
+
+	// ensure all probe lines are driven low, and chill for recovery delay.
+	PORTC &= ~C_MASK;
+	PORTD &= ~D_MASK;
+	PORTE &= ~E_MASK;
+	recovery(1);
+	_delay_us(RECOVERY_US);
+	recovery(0);
+
+	uint8_t index = 0;
+
+	for (uint8_t i=0; i<8; ++i) {
+		if(muxes & (1 << i)) {
+			buffer[index++] = i;
+		}
+	}
+
+	SET_FULL_MUX(MUX_1_1); // crap sample will use this.
+	ADCSRA |= (1 << ADEN) | (1 << ADSC); // enable and start conversions
+	ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
+
+	uint16_t sample;
+
+	while (! (ADCSRA & (1 << ADIF))); // wait until ready.
+	sample = ADC; // 1st sample, icky.
+
+	strobe_w(column);
+	//recovery(0);
+
+	/**
+	 * we are running in continuous mode, so we must setup the next
+	 * read _before_ the current read completes.
+	 *
+	 * setup 0,
+	 * read garbage,
+	 * do not store
+	 *
+	 * setup 1,
+	 * read 0,
+	 * store 0,
+	 *
+	 * ...
+	 *
+	 * setup junk,
+	 * read n
+	 * store n
+	 *
+	 * */
+
+
+	ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
+	//wait for last read to complete.
+	while (! (ADCSRA & (1 << ADIF)));
+	sample = ADC; // throw away strobe'd value.
+
+#if 0
+	for (uint8_t i=0; i <= index; ++i) {
+
+		// setup i'th read.
+		SET_FULL_MUX(buffer[i]); // _next_ read will use this.
+		// wait for i-1'th read to complete:
+		ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
+		while (! (ADCSRA & (1 << ADIF)));
+
+		// retrieve last (i-1'th) read.
+		if (i) {
+			buffer[i-1] = ADC - OFFSET_VOLTAGE;
+		} /*else {
+			buffer[0] = ADC - OFFSET_VOLTAGE;
+		}*/
+
+		//index++;
+	}
+#else
+	for (uint8_t i=0; i < index; ++i) {
+
+		// setup i'th read.
+		SET_FULL_MUX(buffer[i]); // _next_ read will use this.
+
+		ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
+		while (! (ADCSRA & (1 << ADIF)));
+		sample = ADC; // throw away warmup value.
+
+
+
+		/*
+		ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
+		while (! (ADCSRA & (1 << ADIF)));
+		sample = ADC; // throw away warmup value.
+*/
+
+		ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
+		while (! (ADCSRA & (1 << ADIF)));
+
+		// retrieve current read.
+		buffer[i] = ADC - OFFSET_VOLTAGE;
+
+
+	}
+#endif
+
+
+	// turn off adc.
+	ADCSRA &= ~(1 << ADEN);
+
+	// pull all columns' probe-lines low.
+	PORTC &= ~C_MASK;
+	PORTD &= ~D_MASK;
+	PORTE &= ~E_MASK;
+
+	// test for humps. :/
+	/*uint16_t delta = full_av;
+	if(buffer[0] > BUMP_THRESHOLD + delta) {
+		// ze horror.
+		return 1;
+	} else {
+		return 0; //all good.
+	}*/
+	return 0;
+
+}
+
+int sampleColumn_k(uint8_t column, int16_t * buffer) {
+	// ensure all probe lines are driven low, and chill for recovery delay.
+	uint16_t sample;
+
+	ADCSRA |= (1 << ADEN) | (1 << ADSC); // enable and start conversions
+	ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
+
+	// sync up with adc clock:
+	while (! (ADCSRA & (1 << ADIF))); // wait until ready.
+	sample = ADC; // throw it away.
+
+	for(uint8_t mux=0; mux < 8; ++mux) {
+
+		PORTC &= ~C_MASK;
+		PORTD &= ~D_MASK;
+		PORTE &= ~E_MASK;
+
+		SET_FULL_MUX(mux); // our sample will use this
+
+		for(uint8_t i=0; i < 2; ++i) {
+			ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
+			//wait for last read to complete.
+			while (! (ADCSRA & (1 << ADIF)));
+			sample = ADC; // throw away strobe'd value.
+		}
+
+		recovery(0);
+		strobe_w(column);
+
+		ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
+		//wait for last read to complete.
+		while (! (ADCSRA & (1 << ADIF)));
+		sample = ADC; // throw away strobe'd value.
+
+		ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
+		while (! (ADCSRA & (1 << ADIF)));
+
+		// retrieve current read.
+		buffer[mux] = ADC - OFFSET_VOLTAGE;
+		recovery(1);
+
+	}
+
+	// turn off adc.
+	ADCSRA &= ~(1 << ADEN);
+
+	// pull all columns' probe-lines low.
+	PORTC &= ~C_MASK;
+	PORTD &= ~D_MASK;
+	PORTE &= ~E_MASK;
+//		recovery(1);
+
+
+	return 0;
+}
+
+int sampleColumn(uint8_t column) {
+	int rval = 0;
+
+	/*
+	sampleColumn_i(column, 0x0f, samples+SAMPLE_OFFSET);
+	sampleColumn_i(column, 0xf0, samples+SAMPLE_OFFSET + 4 );
+*/
+
+	rval = sampleColumn_k(column, samples+SAMPLE_OFFSET);
+
+	for(uint8_t i=0; i<8; ++i) {
+		if(samples[SAMPLE_OFFSET + i] - adc_mux_averages[i] > BUMP_THRESHOLD) {
+			// was a hump
+
+			_delay_us(BUMP_REST_US);
+			rval++;
+			error = 0x50;
+			error_data = samples[SAMPLE_OFFSET +i]; //  | ((uint16_t)i << 8);
+			return rval;
+		}
+	}
+
+	return rval;
+}
+
+
+
+uint8_t testColumn(uint8_t strobe) {
+    uint8_t column = 0;
+    uint8_t bit = 1;
+    for (uint8_t i=0; i < MUXES_COUNT; ++i) {
+		uint16_t delta = keys_averages[(strobe << MUXES_COUNT_XSHIFT) + i];
+		if ((int16_t)samples[SAMPLE_OFFSET + i] > threshold + delta) {
+			column |= bit;
+		}
+		bit <<= 1;
+	}
+    return column;
+}
+
+int main(void) {
+	// set for 16 MHz clock
+	CPU_PRESCALE(0);
+
+	// 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);
+
+	LED_CONFIG;
+
+	setup_ADC();
+
+	// Configure timer 0 to generate a timer overflow interrupt every
+	// 256*1024 clock cycles, or approx 61 Hz when using 16 MHz clock
+	// This demonstrates how to use interrupts to implement a simple
+	// inactivity timeout.
+	//TCCR0A = 0x00;
+	//TCCR0B = 0x05;
+	//TIMSK0 = (1<<TOIE0);
+
+	DDRC = C_MASK;
+	PORTC = 0;
+	DDRD = D_MASK;
+	PORTD = 0;
+	DDRE = E_MASK;
+	PORTE = 0 ;
+
+	//DDRC |= (1 << 6);
+	//PORTC &= ~(1<< 6);
+
+	//uint16_t strobe = 1;
+
+
+	uint8_t strober = 0;
+	uint32_t full_av_acc = 0;
+
+	for (int i=0; i< STROBE_LINES; ++i) {
+		cur_keymap[i] = 0;
+		//last_keymap[i] = 0;
+		usb_keymap[i] = 0;
+	}
+
+	int16_t mux_averages[MUXES_COUNT];
+	for(int i=0; i < MUXES_COUNT; ++i) {
+		adc_mux_averages[i] = 0x20; // experimentally determined.
+	}
+	int16_t strobe_averages[STROBE_LINES];
+	for(int i=0; i < STROBE_LINES; ++i) {
+		adc_strobe_averages[i] = 0x20; // yup.
+	}
+
+	for(int i=0; i< KEY_COUNT; ++i) {
+		keys_averages[i] = 0x40;
+		keys_averages_acc[i] = (0x400);
+	}
+
+	/** warm things up a bit before we start collecting data, taking real samples. */
+	for(uint8_t i = 0; i< STROBE_LINES; ++i) {
+		sampleColumn(i);
+	}
+
+	while(1) {
+
+		for (strober = 0; strober < STROBE_LINES; ++strober) {
+
+			uint8_t tries;
+			tries = 1;
+			while (tries++ && sampleColumn(strober)) { tries &= 0x7; } // don't waste this one just because the last one was poop.
+			column = testColumn(strober);
+
+			if( column != cur_keymap[strober] && (count >= WARMUP_LOOPS) ) {
+				tests++;
+
+				tries = 1;
+				while (tries++ && sampleColumn(strober)) { tries &= 0x7; } // don't waste this one just because the last one was poop.
+				col_a = testColumn(strober);
+
+				tries = 1;
+				while (tries++ && sampleColumn(strober)) { tries &= 0x7; } // don't waste this one just because the last one was poop.
+				col_b = testColumn(strober);
+
+				tries = 1;
+				while (tries++ && sampleColumn(strober)) { tries &= 0x7; } // don't waste this one just because the last one was poop.
+				col_c = testColumn(strober);
+
+				if( (col_a == col_b) && (col_b == col_c) && (cur_keymap[strober] != col_a) ) {
+					cur_keymap[strober] = col_a;
+					usb_dirty = 1;
+				}
+			}
+
+			if(error == 0x50) {
+				error_data |= (((uint16_t)strober) << 12);
+			}
+
+			for(int i=0; i<MUXES_COUNT; ++i) {
+				full_samples[(strober << MUXES_COUNT_XSHIFT) + i] = samples[SAMPLE_OFFSET + i];
+			}
+
+			strobe_averages[strober] = 0;
+			for (uint8_t i = SAMPLE_OFFSET; i < (SAMPLE_OFFSET + MUXES_COUNT); ++i) {
+				//samples[i] -= samples[i-SAMPLE_OFFSET]; // av; // + full_av); // -something.
+				//samples[i] -= OFFSET_VOLTAGE; // moved to sampleColumn.
+
+				full_av_acc += (samples[i]);
+				mux_averages[i - SAMPLE_OFFSET] += samples[i];
+				strobe_averages[strober] += samples[i];
+				//samples[i] -= (full_av - HYST_T);
+
+				//++count;
+			}
+			adc_strobe_averages[strober] += strobe_averages[strober] >> 3;
+			adc_strobe_averages[strober] >>= 1;
+
+			/** test if we went negative. */
+			if ((adc_strobe_averages[strober] & 0xFF00) && (count
+					>= WARMUP_LOOPS)) {
+				//count = 0; // TODO : constrain properly.
+				error = 0xf; error_data = adc_strobe_averages[strober];
+			}
+
+			uint8_t strobe_line = strober << MUXES_COUNT_XSHIFT;
+			for (int i = 0; i < MUXES_COUNT; ++i) {
+				keys_averages_acc[strobe_line + i]
+						+= samples[SAMPLE_OFFSET + i];
+			}
+
+		} // for strober
+
+		if (count < WARMUP_LOOPS) {
+			error = 0x0C;
+			error_data = count;
+			count++;
+		}
+
+		// verify test key is not down.
+		if((cur_keymap[TEST_KEY_STROBE] & TEST_KEY_MASK) ) {
+			//count=0;
+			error = 0x05;
+			error_data = cur_keymap[TEST_KEY_STROBE] << 8;
+			error_data += full_samples[TEST_KEY_STROBE * 8];
+			//threshold++;
+		}
+
+		// calc mux averages.
+		if (count < WARMUP_LOOPS) {
+			full_av += (full_av_acc >> (7));
+			full_av >>= 1;
+			//full_av = full_av_acc / count;
+			full_av_acc = 0;
+			for (int i=0; i < MUXES_COUNT; ++i) {
+
+// mix in 1/4 of the current average to the running average. -> (@mux_mix = 2)
+#define MUX_MIX 2
+
+				adc_mux_averages[i] = (adc_mux_averages[i] << MUX_MIX) - adc_mux_averages[i];
+				adc_mux_averages[i] += (mux_averages[i] >> 4);
+				adc_mux_averages[i] >>= MUX_MIX;
+
+				mux_averages[i] = 0;
+			}
+
+		}
+
+#define IDLE_COUNT_MASK 0xff
+#define MAX_ICS 8
+
+#define IDLE_COUNT_SHIFT 4
+#define KEYS_AVERAGES_MIX 2
+
+		idle_count++;
+		idle_count &= IDLE_COUNT_MASK;
+
+		if (/*usb_dirty &&*/ (count >= WARMUP_LOOPS) ) {
+			for (int i=0; i<STROBE_LINES; ++i) {
+				usb_keymap[i] = cur_keymap[i];
+			}
+
+			dumpkeys();
+			usb_dirty=0;
+			_delay_ms(2);
+		}
+
+		if (count < WARMUP_LOOPS) {
+			for (uint8_t i = 0; i < KEY_COUNT; ++i) {
+				uint16_t acc = keys_averages_acc[i];
+				uint32_t av = keys_averages[i];
+
+				av = av + av + av + acc;
+				av >>= 2;
+
+				keys_averages[i] = av;
+				keys_averages_acc[i] = 0;
+			}
+		}
+
+
+		if(!idle_count) {
+
+			for (int i=0; i< KEY_COUNT; ++i) {
+				keys_averages_acc[i] = 0;
+			}
+
+			sampleColumn(0x0); // to resync us if we dumped a mess 'o text.
+		}
+	}
+}
+
+
+void debug_println() {
+	usb_debug_putchar('\r');
+	usb_debug_putchar('\n');
+}
+
+
+// This interrupt routine is run approx 61 times per second.
+// A very simple inactivity timeout is implemented, where we
+// will send a space character and print a message to the
+// hid_listen debug message window.
+ISR(TIMER0_OVF_vect) {
+	//idle_count++;
+	/*
+	if (idle_count > 61) {
+		idle_count = 0;
+	}*/
+
+}
+
+void dumpkeys(void) {
+	//print(" \n");
+	if(error) {
+		for (uint8_t i=0; i < STROBE_LINES; ++i) {
+				phex(usb_keymap[i]);
+				usb_debug_putchar(' ');
+
+				//print(" ");
+		}
+		if (count >= WARMUP_LOOPS && error) {
+			dump();
+		}
+
+		print(" : ");
+		phex(error);
+		error = 0;
+		print(" : ");
+		phex16(error_data);
+		error_data = 0;
+		print(" : ");
+		debug_println();
+	}
+
+
+	for(uint8_t i = 0; i < 6; ++i) {
+		keyboard_keys[i] = 0;
+	}
+	keyboard_modifier_keys = 0;
+	uint8_t usbkeycount = 0;
+	for (uint8_t i=0; i < STROBE_LINES; ++i) {
+		for(uint8_t j=0; j<MUXES_COUNT; ++j) {
+			if ( usb_keymap[i] & (1 << j) ) {
+				uint8_t key = pgm_read_byte(matrix122F_to_set3 + ( (i << MUXES_COUNT_XSHIFT) + j) );
+				if(usb_dirty) phex( key );
+				if(usbkeycount < 6) {
+					uint8_t usbkey = pgm_read_byte(page3_2_USB + key);
+
+					if ((usbkey >= 0xe0) && (usbkey <= 0xe7)) { // metas
+						keyboard_modifier_keys |= (1 << (usbkey & 0x07));
+					} else {
+						keyboard_keys[usbkeycount++] =  usbkey;
+					}
+				}
+				if (usb_dirty) usb_debug_putchar(' ');
+			}
+		}
+	}
+	if(usb_dirty) {
+		debug_println();
+	}
+
+	/** shall we send actual keyboard events? */
+#if 0
+	usb_keyboard_send();
+#endif
+
+}
+
+// taken from the datasheet.
+uint8_t readEE(uint16_t offset) {
+	/* Wait for completion of previous write */
+	while(EECR & (1<<EEPE))
+	;
+	/* Set up address register */
+	EEAR = offset;
+	/* Start eeprom read by writing EERE */
+	EECR |= (1<<EERE);
+	/* Return data from Data Register */
+	return EEDR;
+}
+
+// taken from the datasheet - note: writing is very slow. >1ms/byte.
+void writeEE(uint16_t offset, uint8_t data) {
+	/* Wait for completion of previous write */
+	while(EECR & (1<<EEPE))
+	;
+	/* Set up address and Data Registers */
+	EEAR = offset;
+	EEDR = data;
+	/* Write logical one to EEMPE */
+	EECR |= (1<<EEMPE);
+	/* Start eeprom write by setting EEPE */
+	EECR |= (1<<EEPE);
+}
+
+uint8_t dump_count = 0;
+void dump(void) {
+
+#if 0
+	static char once = 0;
+	uint8_t eb;
+
+	if(!once) {
+		print("\nwriting ee");
+		eb = readEE(0x10);
+		eb++;
+		writeEE(0x10, eb);
+
+		once++;
+	}
+
+
+	print("\n ee: ");
+	for(uint16_t i=0x10; i< 0x18; ++i) {
+		phex(readEE(i));
+		pchar(0x20);
+	}
+#endif
+
+	if(!dump_count) {  // we don't want to debug-out during the measurements.
+
+		for(int i =0; i< KEY_COUNT; ++i) {
+			if(!(i & 0x0f)) {
+				print("\n");
+			} else if (!(i & 0x07)) {
+				print("  ");
+			}
+			usb_debug_putchar(' ');
+			//phex16 (keys_averages[(i >> MUXES_COUNT_XSHIFT) + (i & STROBE_LINES_MASK) ]);
+			phex (keys_averages[i]);
+		}
+
+		print("\n");
+
+		for(int i =0; i< KEY_COUNT; ++i) {
+			if(!(i & 0x0f)) {
+				print("\n");
+			} else if (!(i & 0x07)) {
+				print("  ");
+			}
+			usb_debug_putchar(' ');
+			//phex16 (keys_averages[(i >> MUXES_COUNT_XSHIFT) + (i & STROBE_LINES_MASK) ]);
+			//phex16 (keys_averages_acc[i]);
+			phex(full_samples[i]);
+		}
+	}
+
+
+	//}
+
+//	uint8_t cur_strober = 0xe;
+	uint8_t cur_strober = ze_strober;
+	print("\n");
+
+	phex(cur_strober);
+	//print(":         ");
+	print(": ");
+#if 1
+	print("\n");
+	for (uint8_t i=0; i < MUXES_COUNT; ++i) {
+		usb_debug_putchar(' ');
+		phex16(full_samples[(cur_strober << MUXES_COUNT_XSHIFT) + i]);
+	}
+
+	print("\n");
+//	phex(threshold);
+//	print(": ");
+
+	for (uint8_t i=0; i < MUXES_COUNT; ++i) {
+		usb_debug_putchar(' ');
+		phex16(keys_averages[(cur_strober << MUXES_COUNT_XSHIFT) + i]);
+	}
+
+#endif
+	/*
+	for (uint8_t i=0; i< SAMPLES; ++i) {
+		print(" ");
+		phex16(samples[i]);
+		//phex16(ADC);
+	}*/
+	//print(" : ");
+	//usb_debug_putchar((was_active)?' ':'*');
+
+	//phex16(keymap[TEST_KEY_STROBE] & TEST_KEY_MASK);
+	/*print(" "); */
+	//phex(keymap[TEST_KEY_STROBE]);
+
+
+	//print("\n");
+	//print(":");
+	//phex(full_av);
+	//phex16(count);
+	//print(" : ");
+	print("\n");
+
+	for (uint8_t i=0; i < STROBE_LINES; ++i) {
+		phex(cur_keymap[i]);
+		usb_debug_putchar(' ');
+
+		//print(" ");
+	}
+
+
+	//print(": ");
+	//phex(adc_strobe_averages[ze_strober]);
+	//usb_debug_putchar(' ');
+
+
+
+	for (uint8_t i=0; i < MUXES_COUNT; ++i) {
+		usb_debug_putchar(' ');
+		//phex16(adc_mux_averages[i] + adc_strobe_averages[ze_strober] - full_av);
+		//phex16((adc_mux_averages[i] + adc_strobe_averages[ze_strober]) >> 1);
+		//phex16((adc_mux_averages[i] * 3  + adc_strobe_averages[ze_strober]) >> 2);
+		//phex16(adc_mux_averages[i] + threshold);
+		//phex16(gsamples[i + SAMPLE_OFFSET] - (adc_mux_averages[i] + threshold) + 0x100);
+		//phex16(keys_averages[(ze_strober << MUXES_COUNT_XSHIFT) + i] + (uint8_t)threshold);
+		phex16(keys_averages[(ze_strober << MUXES_COUNT_XSHIFT) + i]);
+	}
+
+	if(error) {
+		usb_debug_putchar(' ');
+		phex (error);
+		usb_debug_putchar(' ');
+		phex16(error_data);
+		error = 0;
+		error_data = 0;
+	}
+	//print("\n");
+
+	ze_strober++;
+	ze_strober &= 0xf;
+
+
+	dump_count++;
+	dump_count &= 0x0f;
+
+
+
+	//ze_strobe = (1 << (ze_strober ) );
+
+
+
+	//phex(ADCSRA);
+	//print(" ");
+			//print("\n");
+	//usb_keyboard_press(KEY_SPACE, 0);
+
+//		if(blink) {
+//			LED_ON;
+//		} else {
+//			LED_OFF;
+//		}
+//		blink ^= 1;
+}
+
+
+/*
+int oldmain(void) {
+	uint8_t b, d, mask, i, reset_idle;
+	uint8_t b_prev=0xFF, d_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
+	DDRD = 0x00;
+	DDRB = 0x00;
+	PORTB = 0xFF;
+	PORTD = 0xFF;
+
+	// 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 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);
+
+	// Configure timer 0 to generate a timer overflow interrupt every
+	// 256*1024 clock cycles, or approx 61 Hz when using 16 MHz clock
+	// This demonstrates how to use interrupts to implement a simple
+	// inactivity timeout.
+	TCCR0A = 0x00;
+	TCCR0B = 0x05;
+	TIMSK0 = (1<<TOIE0);
+
+	print("Begin keyboard example program\n");
+	print("All Port B or Port D pins are inputs with pullup resistors.\n");
+	print("Any connection to ground on Port B or D pins will result in\n");
+	print("keystrokes sent to the PC (and debug messages here).\n");
+	while (1) {
+		// read all port B and port D pins
+		b = PINB;
+		d = PIND;
+		// check if any pins are low, but were high previously
+		mask = 1;
+		reset_idle = 0;
+		for (i=0; i<8; i++) {
+			if (((b & mask) == 0) && (b_prev & mask) != 0) {
+				usb_keyboard_press(KEY_B, KEY_SHIFT);
+				usb_keyboard_press(number_keys[i], 0);
+				print("Port B, bit ");
+				phex(i);
+				print("\n");
+				reset_idle = 1;
+			}
+			if (((d & mask) == 0) && (d_prev & mask) != 0) {
+				usb_keyboard_press(KEY_D, KEY_SHIFT);
+				usb_keyboard_press(number_keys[i], 0);
+				print("Port D, bit ");
+				phex(i);
+				print("\n");
+				reset_idle = 1;
+			}
+			mask = mask << 1;
+		}
+		// if any keypresses were detected, reset the idle counter
+		if (reset_idle) {
+			// variables shared with interrupt routines must be
+			// accessed carefully so the interrupt routine doesn't
+			// try to use the variable in the middle of our access
+			cli();
+			idle_count = 0;
+			sei();
+		}
+		// 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;
+		d_prev = d;
+		_delay_ms(2);
+	}
+}
+*/
+
diff --git a/Scan/avr-capsense/setup.cmake b/Scan/avr-capsense/setup.cmake
new file mode 100755
index 0000000..bf516c2
--- /dev/null
+++ b/Scan/avr-capsense/setup.cmake
@@ -0,0 +1,43 @@
+###| CMake Kiibohd Controller Scan Module |###
+#
+# Written by Jacob Alexander in 2011 for the Kiibohd Controller
+#
+# Released into the Public Domain
+#
+###
+
+
+###
+# Module C files
+#
+
+#| XXX Requires the ../ due to how the paths are constructed
+set( SCAN_SRCS
+	../matrix/matrix_scan.c
+	../matrix/scan_loop.c
+)
+
+
+###
+# Module Specific Options
+#
+add_definitions( -I${HEAD_DIR}/Keymap )
+add_definitions(
+	-I${HEAD_DIR}/Scan/matrix
+)	
+
+#| Keymap Settings
+add_definitions(
+	-DMODIFIER_MASK=budkeypad_ModifierMask
+	#-DKEYINDEX_MASK=budkeypad_TheProfosistMap
+	-DKEYINDEX_MASK=budkeypad_DefaultMap
+)
+
+
+###
+# Compiler Family Compatibility
+#
+set( ScanModuleCompatibility
+	avr
+)
+
diff --git a/cmake_install.cmake b/cmake_install.cmake
new file mode 100755
index 0000000..433b8f1
--- /dev/null
+++ b/cmake_install.cmake
@@ -0,0 +1,39 @@
+# Install script for directory: L:/haata/kiibohd
+
+# Set the install prefix
+IF(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  SET(CMAKE_INSTALL_PREFIX "C:/Program Files (x86)/kiibohd_controller")
+ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX)
+STRING(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+IF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  IF(BUILD_TYPE)
+    STRING(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  ELSE(BUILD_TYPE)
+    SET(CMAKE_INSTALL_CONFIG_NAME "")
+  ENDIF(BUILD_TYPE)
+  MESSAGE(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+ENDIF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+
+# Set the component getting installed.
+IF(NOT CMAKE_INSTALL_COMPONENT)
+  IF(COMPONENT)
+    MESSAGE(STATUS "Install component: \"${COMPONENT}\"")
+    SET(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  ELSE(COMPONENT)
+    SET(CMAKE_INSTALL_COMPONENT)
+  ENDIF(COMPONENT)
+ENDIF(NOT CMAKE_INSTALL_COMPONENT)
+
+IF(CMAKE_INSTALL_COMPONENT)
+  SET(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt")
+ELSE(CMAKE_INSTALL_COMPONENT)
+  SET(CMAKE_INSTALL_MANIFEST "install_manifest.txt")
+ENDIF(CMAKE_INSTALL_COMPONENT)
+
+FILE(WRITE "L:/haata/kiibohd/${CMAKE_INSTALL_MANIFEST}" "")
+FOREACH(file ${CMAKE_INSTALL_MANIFEST_FILES})
+  FILE(APPEND "L:/haata/kiibohd/${CMAKE_INSTALL_MANIFEST}" "${file}\n")
+ENDFOREACH(file)
diff --git a/winbuild.sh b/winbuild.sh
new file mode 100755
index 0000000..d2d260c
--- /dev/null
+++ b/winbuild.sh
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+#temp jo
+#export PATH="/c/WinAVR-20100110/bin:/c/Program Files (x86)/CMake 2.8/bin:${PATH}"
+#echo $PATH
+export PATH="/c/WinAVR-20100110/bin:/c/Program Files (x86)/CMake 2.8/bin:/usr/local/bin:/usr/bin:/bin:/c/Windows/system32"
+echo $PATH
+
+
+which cmake.exe
+which -a cmake.exe
+which avr-gcc
+which make
+#alias cmake="cmake.exe"
+#alias make="avr-nm"
+
+#cd build
+cmake -G "Unix Makefiles" -D \
+CMAKE_C_COMPILER="C:/WinAVR-20100110/bin/avr-gcc.exe" \
+-D CMAKE_CXX_COMPILER="C:/WinAVR-20100110/bin/avr-g++.exe" .
+#cd ..
+make
+#nm
+
+#./buildall.bash