|
|
@@ -1,7 +1,18 @@ |
|
|
|
/* Copyright (C) 2011-2013 by Joseph Makuch |
|
|
|
* Additions by Jacob Alexander (2013) |
|
|
|
* |
|
|
|
* dfj, put whatever license here you want -HaaTa |
|
|
|
* 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 3 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/>. |
|
|
|
*/ |
|
|
|
|
|
|
|
// ----- Includes ----- |
|
|
@@ -20,12 +31,7 @@ |
|
|
|
|
|
|
|
// ----- Defines ----- |
|
|
|
|
|
|
|
// TODO dfj defines...needs cleaning up and commenting... |
|
|
|
#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)) |
|
|
|
|
|
|
|
// TODO dfj defines...needs commenting and maybe some cleaning... |
|
|
|
#define MAX_PRESS_DELTA_MV 470 |
|
|
|
#define THRESHOLD_MV (MAX_PRESS_DELTA_MV >> 1) |
|
|
|
//(2560 / (0x3ff/2)) ~= 5 |
|
|
@@ -36,161 +42,81 @@ |
|
|
|
|
|
|
|
#define BUMP_DETECTION 0 |
|
|
|
#define BUMP_THRESHOLD 0x50 |
|
|
|
//((THRESHOLD) * 3) |
|
|
|
#define BUMP_REST_US 1200 |
|
|
|
|
|
|
|
#define STROBE_SETTLE 1 |
|
|
|
#define MUX_SETTLE 1 |
|
|
|
|
|
|
|
#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 |
|
|
|
|
|
|
|
|
|
|
|
#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 |
|
|
|
|
|
|
|
// Strobe Masks |
|
|
|
#define D_MASK (0xff) |
|
|
|
#define E_MASK (0x03) |
|
|
|
#define C_MASK (0xff) |
|
|
|
|
|
|
|
// set ADC clock prescale |
|
|
|
// set ADC clock prescale |
|
|
|
#define PRESCALE_MASK ((1 << ADPS0) | (1 << ADPS1) | (1 << ADPS2)) |
|
|
|
#define PRESCALE_SHIFT (ADPS0) |
|
|
|
#define PRESCALE 3 |
|
|
|
|
|
|
|
|
|
|
|
#ifdef EXTENDED_STROBE |
|
|
|
|
|
|
|
#define STROBE_LINES 18 |
|
|
|
|
|
|
|
#else |
|
|
|
|
|
|
|
// TODO Remove this define when unnecessary -HaaTa |
|
|
|
#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 2 |
|
|
|
|
|
|
|
#define SAMPLES 10 |
|
|
|
|
|
|
|
|
|
|
|
#define SAMPLE_OFFSET ((SAMPLES) - MUXES_COUNT) |
|
|
|
//#define SAMPLE_OFFSET 9 |
|
|
|
#define STROBE_OFFSET 0 |
|
|
|
|
|
|
|
#define SAMPLE_CONTROL 3 |
|
|
|
|
|
|
|
// TODO Figure out calculation or best way to determine at startup -HaaTa |
|
|
|
//#define DEFAULT_KEY_BASE 0xc8 |
|
|
|
#define DEFAULT_KEY_BASE 0x95 |
|
|
|
|
|
|
|
#define KEY_COUNT ((STROBE_LINES) * (MUXES_COUNT)) |
|
|
|
|
|
|
|
#define LX2FX |
|
|
|
|
|
|
|
|
|
|
|
#define RECOVERY_CONTROL 1 |
|
|
|
#define RECOVERY_SOURCE 0 |
|
|
|
#define RECOVERY_SINK 2 |
|
|
|
|
|
|
|
#define RECOVERY_SOURCE 0 |
|
|
|
#define RECOVERY_SINK 2 |
|
|
|
#define RECOVERY_MASK 0x03 |
|
|
|
|
|
|
|
#define ON 1 |
|
|
|
#define ON 1 |
|
|
|
#define OFF 0 |
|
|
|
|
|
|
|
|
|
|
|
// mix in 1/4 of the current average to the running average. -> (@mux_mix = 2) |
|
|
|
#define MUX_MIX 2 |
|
|
|
|
|
|
|
|
|
|
|
#define IDLE_COUNT_MASK 0xff |
|
|
|
#define IDLE_COUNT_MAX (IDLE_COUNT_MASK + 1) |
|
|
|
#define IDLE_COUNT_SHIFT 8 |
|
|
|
|
|
|
|
#define KEYS_AVERAGES_MIX 2 |
|
|
|
|
|
|
|
|
|
|
|
#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 |
|
|
|
|
|
|
|
|
|
|
|
// av = (av << shift) - av + sample; av >>= shift |
|
|
|
// e.g. 1 -> (av + sample) / 2 simple average of new and old |
|
|
|
// 2 -> (3 * av + sample) / 4 i.e. 3:1 mix of old to new. |
|
|
|
// 3 -> (7 * av + sample) / 8 i.e. 7:1 mix of old to new. |
|
|
|
#define KEYS_AVERAGES_MIX_SHIFT 3 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@@ -201,18 +127,11 @@ |
|
|
|
if ( KeyIndex_BufferUsed < KEYBOARD_BUFFER ) \ |
|
|
|
KeyIndex_Buffer[KeyIndex_BufferUsed++] = byte |
|
|
|
|
|
|
|
|
|
|
|
// TODO dfj macros...needs cleaning up and commenting... |
|
|
|
#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))) |
|
|
|
|
|
|
|
#define SET_MUX(X) ((ADMUX) = (((ADMUX) & ~(MUX_MASK)) | ((X) & (MUX_MASK)))) |
|
|
|
// Select mux |
|
|
|
#define SET_FULL_MUX(X) ((ADMUX) = (((ADMUX) & ~(FULL_MUX_MASK)) | ((X) & (FULL_MUX_MASK)))) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ----- Variables ----- |
|
|
|
|
|
|
|
// Buffer used to inform the macro processing module which keys have been detected as pressed |
|
|
@@ -221,39 +140,25 @@ volatile uint8_t KeyIndex_BufferUsed; |
|
|
|
|
|
|
|
|
|
|
|
// TODO dfj variables...needs cleaning up and commenting |
|
|
|
uint8_t blink = 0; |
|
|
|
volatile uint16_t full_av = 0; |
|
|
|
|
|
|
|
/**/ uint8_t ze_strober = 0; |
|
|
|
uint8_t ze_strober = 0; |
|
|
|
|
|
|
|
uint16_t samples [SAMPLES]; |
|
|
|
|
|
|
|
//int16_t gsamples [SAMPLES]; |
|
|
|
|
|
|
|
int16_t adc_mux_averages[MUXES_COUNT]; |
|
|
|
int16_t adc_strobe_averages[STROBE_LINES]; |
|
|
|
|
|
|
|
uint16_t adc_mux_averages [MUXES_COUNT]; |
|
|
|
uint16_t adc_strobe_averages[STROBE_LINES]; |
|
|
|
|
|
|
|
uint8_t cur_keymap[STROBE_LINES]; |
|
|
|
// /**/ int8_t last_keymap[STROBE_LINES]; |
|
|
|
uint8_t usb_keymap[STROBE_LINES]; |
|
|
|
uint16_t keys_down=0; |
|
|
|
|
|
|
|
uint8_t dirty; |
|
|
|
uint8_t unstable; |
|
|
|
uint8_t usb_dirty; |
|
|
|
|
|
|
|
uint16_t threshold = 0x25; // HaaTa Hack -TODO |
|
|
|
//uint16_t threshold = 0x16; // HaaTa Hack -TODO |
|
|
|
//uint16_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; |
|
|
|
|
|
|
|
uint8_t column = 0; |
|
|
|
|
|
|
|
uint16_t keys_averages_acc[KEY_COUNT]; |
|
|
|
uint16_t keys_averages[KEY_COUNT]; |
|
|
@@ -261,30 +166,22 @@ uint16_t keys_averages_acc_count=0; |
|
|
|
|
|
|
|
uint8_t full_samples[KEY_COUNT]; |
|
|
|
|
|
|
|
// 0x9f...f |
|
|
|
// #define COUNT_MASK 0x9fff |
|
|
|
// #define COUNT_HIGH_BIT (INT16_MIN) |
|
|
|
// TODO: change this to 'booting', then count down. |
|
|
|
uint16_t boot_count = 0; |
|
|
|
|
|
|
|
uint16_t idle_count=0; |
|
|
|
uint16_t idle_count = 0; |
|
|
|
uint8_t idle = 1; |
|
|
|
|
|
|
|
uint16_t count = 0; |
|
|
|
|
|
|
|
uint8_t error = 0; |
|
|
|
uint16_t error_data = 0; |
|
|
|
|
|
|
|
|
|
|
|
int16_t mux_averages[MUXES_COUNT]; |
|
|
|
int16_t strobe_averages[STROBE_LINES]; |
|
|
|
uint16_t mux_averages[MUXES_COUNT]; |
|
|
|
uint16_t strobe_averages[STROBE_LINES]; |
|
|
|
|
|
|
|
uint8_t dump_count = 0; |
|
|
|
|
|
|
|
|
|
|
|
//uint8_t column =0; |
|
|
|
uint16_t db_delta = 0; |
|
|
|
uint8_t db_sample = 0; |
|
|
|
uint8_t db_sample = 0; |
|
|
|
uint16_t db_threshold = 0; |
|
|
|
|
|
|
|
|
|
|
@@ -314,23 +211,17 @@ inline void scan_setup() |
|
|
|
// TODO dfj code...needs cleanup + commenting... |
|
|
|
setup_ADC(); |
|
|
|
|
|
|
|
DDRC = C_MASK; |
|
|
|
DDRC = C_MASK; |
|
|
|
PORTC = 0; |
|
|
|
DDRD = D_MASK; |
|
|
|
DDRD = D_MASK; |
|
|
|
PORTD = 0; |
|
|
|
DDRE = E_MASK; |
|
|
|
DDRE = E_MASK; |
|
|
|
PORTE = 0 ; |
|
|
|
|
|
|
|
//DDRC |= (1 << 6); |
|
|
|
//PORTC &= ~(1<< 6); |
|
|
|
|
|
|
|
//uint16_t strobe = 1; |
|
|
|
|
|
|
|
|
|
|
|
// TODO all this code should probably be in scan_resetKeyboard |
|
|
|
for (int i=0; i < STROBE_LINES; ++i) { |
|
|
|
cur_keymap[i] = 0; |
|
|
|
//last_keymap[i] = 0; |
|
|
|
usb_keymap[i] = 0; |
|
|
|
} |
|
|
|
|
|
|
@@ -366,30 +257,31 @@ inline uint8_t scan_loop() |
|
|
|
uint8_t strober = 0; |
|
|
|
uint32_t full_av_acc = 0; |
|
|
|
|
|
|
|
for (strober = 0; strober < STROBE_LINES; ++strober) { |
|
|
|
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. |
|
|
|
uint8_t tries = 1; |
|
|
|
while ( tries++ && sampleColumn( strober ) ) { tries &= 0x7; } // don't waste this one just because the last one was poop. |
|
|
|
column = testColumn(strober); |
|
|
|
|
|
|
|
idle |= column; // if column has any pressed keys, then we are not idle. |
|
|
|
|
|
|
|
if( column != cur_keymap[strober] && (boot_count >= WARMUP_LOOPS) ) { |
|
|
|
tests++; |
|
|
|
|
|
|
|
if( column != cur_keymap[strober] && ( boot_count >= WARMUP_LOOPS ) ) |
|
|
|
{ |
|
|
|
cur_keymap[strober] = column; |
|
|
|
usb_dirty = 1; |
|
|
|
} |
|
|
|
|
|
|
|
idle |= usb_dirty; // if any keys have changed inc. released, then we are not idle. |
|
|
|
|
|
|
|
if(error == 0x50) { |
|
|
|
if ( error == 0x50 ) |
|
|
|
{ |
|
|
|
error_data |= (((uint16_t)strober) << 12); |
|
|
|
} |
|
|
|
|
|
|
|
uint8_t strobe_line = strober << MUXES_COUNT_XSHIFT; |
|
|
|
for(int i=0; i<MUXES_COUNT; ++i) { |
|
|
|
for ( int i = 0; i < MUXES_COUNT; ++i ) |
|
|
|
{ |
|
|
|
// discard sketchy low bit, and meaningless high bits. |
|
|
|
uint8_t sample = samples[SAMPLE_OFFSET + i] >> 1; |
|
|
|
full_samples[strobe_line + i] = sample; |
|
|
@@ -398,18 +290,13 @@ inline uint8_t scan_loop() |
|
|
|
keys_averages_acc_count++; |
|
|
|
|
|
|
|
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. |
|
|
|
|
|
|
|
for ( uint8_t i = SAMPLE_OFFSET; i < ( SAMPLE_OFFSET + MUXES_COUNT ); ++i ) |
|
|
|
{ |
|
|
|
full_av_acc += (samples[i]); |
|
|
|
#ifdef COLLECT_STROBE_AVERAGES |
|
|
|
mux_averages[i - SAMPLE_OFFSET] += samples[i]; |
|
|
|
strobe_averages[strober] += samples[i]; |
|
|
|
#endif |
|
|
|
//samples[i] -= (full_av - HYST_T); |
|
|
|
|
|
|
|
//++count; |
|
|
|
} |
|
|
|
|
|
|
|
#ifdef COLLECT_STROBE_AVERAGES |
|
|
@@ -417,8 +304,8 @@ inline uint8_t scan_loop() |
|
|
|
adc_strobe_averages[strober] >>= 1; |
|
|
|
|
|
|
|
/** test if we went negative. */ |
|
|
|
if ((adc_strobe_averages[strober] & 0xFF00) && (boot_count |
|
|
|
>= WARMUP_LOOPS)) { |
|
|
|
if ( ( adc_strobe_averages[strober] & 0xFF00 ) && ( boot_count >= WARMUP_LOOPS ) ) |
|
|
|
{ |
|
|
|
error = 0xf; error_data = adc_strobe_averages[strober]; |
|
|
|
} |
|
|
|
#endif |
|
|
@@ -426,8 +313,8 @@ inline uint8_t scan_loop() |
|
|
|
|
|
|
|
#ifdef VERIFY_TEST_PAD |
|
|
|
// verify test key is not down. |
|
|
|
if((cur_keymap[TEST_KEY_STROBE] & TEST_KEY_MASK) ) { |
|
|
|
//count=0; |
|
|
|
if ( ( cur_keymap[TEST_KEY_STROBE] & TEST_KEY_MASK ) ) |
|
|
|
{ |
|
|
|
error = 0x05; |
|
|
|
error_data = cur_keymap[TEST_KEY_STROBE] << 8; |
|
|
|
error_data += full_samples[TEST_KEY_STROBE * 8]; |
|
|
@@ -437,14 +324,14 @@ inline uint8_t scan_loop() |
|
|
|
|
|
|
|
#ifdef COLLECT_STROBE_AVERAGES |
|
|
|
// calc mux averages. |
|
|
|
if (boot_count < WARMUP_LOOPS) { |
|
|
|
if ( boot_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) { |
|
|
|
#define MUX_MIX 2 // mix in 1/4 of the current average to the running average. -> (@mux_mix = 2) |
|
|
|
for ( int i = 0; i < MUXES_COUNT; ++i ) |
|
|
|
{ |
|
|
|
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; |
|
|
@@ -454,12 +341,6 @@ inline uint8_t scan_loop() |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
// av = (av << shift) - av + sample; av >>= shift |
|
|
|
// e.g. 1 -> (av + sample) / 2 simple average of new and old |
|
|
|
// 2 -> (3 * av + sample) / 4 i.e. 3:1 mix of old to new. |
|
|
|
// 3 -> (7 * av + sample) / 8 i.e. 7:1 mix of old to new. |
|
|
|
#define KEYS_AVERAGES_MIX_SHIFT 3 |
|
|
|
|
|
|
|
/** aggregate if booting, or if idle; |
|
|
|
* else, if not booting, check for dirty USB. |
|
|
|
* */ |
|
|
@@ -467,20 +348,23 @@ inline uint8_t scan_loop() |
|
|
|
idle_count++; |
|
|
|
idle_count &= IDLE_COUNT_MASK; |
|
|
|
|
|
|
|
idle = idle && !keys_down; |
|
|
|
|
|
|
|
if (boot_count < WARMUP_LOOPS) { |
|
|
|
if ( boot_count < WARMUP_LOOPS ) |
|
|
|
{ |
|
|
|
error = 0x0C; |
|
|
|
error_data = boot_count; |
|
|
|
boot_count++; |
|
|
|
} else { // count >= WARMUP_LOOPS |
|
|
|
if (usb_dirty) { |
|
|
|
for (int i=0; i < STROBE_LINES; ++i) { |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
if ( usb_dirty ) |
|
|
|
{ |
|
|
|
for ( int i = 0; i < STROBE_LINES; ++i ) |
|
|
|
{ |
|
|
|
usb_keymap[i] = cur_keymap[i]; |
|
|
|
} |
|
|
|
|
|
|
|
dumpkeys(); |
|
|
|
usb_dirty=0; |
|
|
|
usb_dirty = 0; |
|
|
|
memset(((void *)keys_averages_acc), 0, (size_t)(KEY_COUNT * sizeof (uint16_t))); |
|
|
|
keys_averages_acc_count = 0; |
|
|
|
idle_count = 0; |
|
|
@@ -488,10 +372,13 @@ inline uint8_t scan_loop() |
|
|
|
_delay_us(100); |
|
|
|
} |
|
|
|
|
|
|
|
if (!idle_count) { |
|
|
|
if(idle) { |
|
|
|
if ( !idle_count ) |
|
|
|
{ |
|
|
|
if( idle ) |
|
|
|
{ |
|
|
|
// aggregate |
|
|
|
for (uint8_t i = 0; i < KEY_COUNT; ++i) { |
|
|
|
for ( uint8_t i = 0; i < KEY_COUNT; ++i ) |
|
|
|
{ |
|
|
|
uint16_t acc = keys_averages_acc[i] >> IDLE_COUNT_SHIFT; |
|
|
|
uint32_t av = keys_averages[i]; |
|
|
|
|
|
|
@@ -504,7 +391,8 @@ inline uint8_t scan_loop() |
|
|
|
} |
|
|
|
keys_averages_acc_count = 0; |
|
|
|
|
|
|
|
if(boot_count >= WARMUP_LOOPS) { |
|
|
|
if ( boot_count >= WARMUP_LOOPS ) |
|
|
|
{ |
|
|
|
dump(); |
|
|
|
} |
|
|
|
|
|
|
@@ -568,7 +456,7 @@ void scan_finishedWithUSBBuffer( uint8_t sentKeys ) |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void _delay_loop(uint8_t __count) |
|
|
|
void _delay_loop( uint8_t __count ) |
|
|
|
{ |
|
|
|
__asm__ volatile ( |
|
|
|
"1: dec %0" "\n\t" |
|
|
@@ -579,17 +467,16 @@ void _delay_loop(uint8_t __count) |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void setup_ADC (void) { |
|
|
|
void setup_ADC() |
|
|
|
{ |
|
|
|
// 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) |
|
|
@@ -597,10 +484,6 @@ void setup_ADC (void) { |
|
|
|
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. |
|
|
@@ -609,38 +492,23 @@ void setup_ADC (void) { |
|
|
|
//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 |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void recovery(uint8_t on) { |
|
|
|
DDRB |= (1 << RECOVERY_CONTROL); |
|
|
|
|
|
|
|
PORTB &= ~(1 << RECOVERY_SINK); // SINK always zero |
|
|
|
DDRB &= ~(1 << RECOVERY_SOURCE); // SOURCE high imp |
|
|
|
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) { |
|
|
|
if ( on ) |
|
|
|
{ |
|
|
|
// set strobes to sink to gnd. |
|
|
|
DDRC |= C_MASK; |
|
|
|
DDRD |= D_MASK; |
|
|
@@ -650,38 +518,38 @@ void recovery(uint8_t on) { |
|
|
|
PORTD &= ~D_MASK; |
|
|
|
PORTE &= ~E_MASK; |
|
|
|
|
|
|
|
DDRB |= (1 << RECOVERY_SINK); // SINK pull |
|
|
|
|
|
|
|
DDRB |= (1 << RECOVERY_SINK); // SINK pull |
|
|
|
PORTB |= (1 << RECOVERY_CONTROL); |
|
|
|
|
|
|
|
PORTB |= (1 << RECOVERY_SOURCE); // SOURCE high |
|
|
|
DDRB |= (1 << RECOVERY_SOURCE); |
|
|
|
} else { |
|
|
|
// _delay_loop(10); |
|
|
|
DDRB |= (1 << RECOVERY_SOURCE); |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
PORTB &= ~(1 << RECOVERY_CONTROL); |
|
|
|
|
|
|
|
DDRB &= ~(1 << RECOVERY_SOURCE); |
|
|
|
DDRB &= ~(1 << RECOVERY_SOURCE); |
|
|
|
PORTB &= ~(1 << RECOVERY_SOURCE); // SOURCE low |
|
|
|
DDRB &= ~(1 << RECOVERY_SINK); // SINK high-imp |
|
|
|
|
|
|
|
//DDRB &= ~(1 << RECOVERY_SINK); |
|
|
|
DDRB &= ~(1 << RECOVERY_SINK); // SINK high-imp |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void hold_sample(uint8_t on) { |
|
|
|
if (!on) { |
|
|
|
void hold_sample( uint8_t on ) |
|
|
|
{ |
|
|
|
if ( !on ) |
|
|
|
{ |
|
|
|
PORTB |= (1 << SAMPLE_CONTROL); |
|
|
|
DDRB |= (1 << SAMPLE_CONTROL); |
|
|
|
} else { |
|
|
|
DDRB |= (1 << SAMPLE_CONTROL); |
|
|
|
DDRB |= (1 << SAMPLE_CONTROL); |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
DDRB |= (1 << SAMPLE_CONTROL); |
|
|
|
PORTB &= ~(1 << SAMPLE_CONTROL); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void strobe_w(uint8_t strobe_num) { |
|
|
|
|
|
|
|
void strobe_w( uint8_t strobe_num ) |
|
|
|
{ |
|
|
|
PORTC &= ~(C_MASK); |
|
|
|
PORTD &= ~(D_MASK); |
|
|
|
PORTE &= ~(E_MASK); |
|
|
@@ -873,65 +741,61 @@ void strobe_w(uint8_t strobe_num) { |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
inline uint16_t getADC() { |
|
|
|
inline uint16_t getADC(void) |
|
|
|
{ |
|
|
|
ADCSRA |= (1 << ADIF); // clear int flag by writing 1. |
|
|
|
|
|
|
|
//wait for last read to complete. |
|
|
|
while (! (ADCSRA & (1 << ADIF))); |
|
|
|
while ( !( ADCSRA & (1 << ADIF) ) ); |
|
|
|
|
|
|
|
return ADC; // return sample |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
int sampleColumn_8x(uint8_t column, uint16_t * buffer) { |
|
|
|
int sampleColumn_8x( uint8_t column, uint16_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 |
|
|
|
|
|
|
|
// sync up with adc clock: |
|
|
|
//sample = getADC(); |
|
|
|
|
|
|
|
PORTC &= ~C_MASK; |
|
|
|
PORTD &= ~D_MASK; |
|
|
|
PORTE &= ~E_MASK; |
|
|
|
|
|
|
|
PORTF = 0; |
|
|
|
DDRF = 0; |
|
|
|
DDRF = 0; |
|
|
|
|
|
|
|
recovery(OFF); |
|
|
|
strobe_w(column); |
|
|
|
|
|
|
|
hold_sample(OFF); |
|
|
|
SET_FULL_MUX(0); |
|
|
|
for(uint8_t i=0; i < STROBE_SETTLE; ++i) { |
|
|
|
sample = getADC(); |
|
|
|
} |
|
|
|
|
|
|
|
for ( uint8_t i = 0; i < STROBE_SETTLE; ++i ) { getADC(); } |
|
|
|
|
|
|
|
hold_sample(ON); |
|
|
|
|
|
|
|
#undef MUX_SETTLE |
|
|
|
|
|
|
|
#if (MUX_SETTLE) |
|
|
|
for(uint8_t mux=0; mux < 8; ++mux) { |
|
|
|
|
|
|
|
for ( uint8_t mux = 0; mux < 8; ++mux ) |
|
|
|
{ |
|
|
|
SET_FULL_MUX(mux); // our sample will use this |
|
|
|
// wait for mux to settle. |
|
|
|
for(uint8_t i=0; i < MUX_SETTLE; ++i) { |
|
|
|
sample = getADC(); |
|
|
|
} |
|
|
|
|
|
|
|
// wait for mux to settle. |
|
|
|
for ( uint8_t i = 0; i < MUX_SETTLE; ++i ) { getADC(); } |
|
|
|
|
|
|
|
// retrieve current read. |
|
|
|
buffer[mux] = getADC();// - OFFSET_VOLTAGE; |
|
|
|
|
|
|
|
buffer[mux] = getADC(); |
|
|
|
} |
|
|
|
#else |
|
|
|
uint8_t mux=0; |
|
|
|
uint8_t mux = 0; |
|
|
|
SET_FULL_MUX(mux); |
|
|
|
sample = getADC(); // throw away; unknown mux. |
|
|
|
getADC(); // throw away; unknown mux. |
|
|
|
do { |
|
|
|
SET_FULL_MUX(mux + 1); // our *next* sample will use this |
|
|
|
|
|
|
|
// retrieve current read. |
|
|
|
buffer[mux] = getADC();// - OFFSET_VOLTAGE; |
|
|
|
buffer[mux] = getADC(); |
|
|
|
mux++; |
|
|
|
|
|
|
|
} while (mux < 8); |
|
|
@@ -956,16 +820,18 @@ int sampleColumn_8x(uint8_t column, uint16_t * buffer) { |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
int sampleColumn(uint8_t column) { |
|
|
|
int sampleColumn( uint8_t column ) |
|
|
|
{ |
|
|
|
int rval = 0; |
|
|
|
|
|
|
|
rval = sampleColumn_8x(column, samples+SAMPLE_OFFSET); |
|
|
|
rval = sampleColumn_8x( column, samples + SAMPLE_OFFSET ); |
|
|
|
|
|
|
|
#if (BUMP_DETECTION) |
|
|
|
for(uint8_t i=0; i<8; ++i) { |
|
|
|
if(samples[SAMPLE_OFFSET + i] - adc_mux_averages[i] > BUMP_THRESHOLD) { |
|
|
|
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; |
|
|
@@ -979,15 +845,15 @@ int sampleColumn(uint8_t column) { |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
uint8_t testColumn(uint8_t strobe) |
|
|
|
uint8_t testColumn( uint8_t strobe ) |
|
|
|
{ |
|
|
|
uint8_t column = 0; |
|
|
|
uint8_t bit = 1; |
|
|
|
for (uint8_t i = 0; i < MUXES_COUNT; ++i) |
|
|
|
for ( uint8_t i = 0; i < MUXES_COUNT; ++i ) |
|
|
|
{ |
|
|
|
uint16_t delta = keys_averages[(strobe << MUXES_COUNT_XSHIFT) + i]; |
|
|
|
|
|
|
|
if ((db_sample = samples[SAMPLE_OFFSET + i] >> 1) > (db_threshold = threshold) + (db_delta = delta)) |
|
|
|
if ( (db_sample = samples[SAMPLE_OFFSET + i] >> 1) > (db_threshold = threshold) + (db_delta = delta) ) |
|
|
|
{ |
|
|
|
column |= bit; |
|
|
|
} |
|
|
@@ -1014,17 +880,20 @@ uint8_t testColumn(uint8_t strobe) |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void dumpkeys(void) { |
|
|
|
//print(" \n"); |
|
|
|
if(error) { |
|
|
|
/* |
|
|
|
if (count >= WARMUP_LOOPS && error) { |
|
|
|
void dumpkeys() |
|
|
|
{ |
|
|
|
if ( error ) |
|
|
|
{ |
|
|
|
erro_print("Problem detected..."); |
|
|
|
|
|
|
|
if ( boot_count >= WARMUP_LOOPS ) |
|
|
|
{ |
|
|
|
dump(); |
|
|
|
} |
|
|
|
*/ |
|
|
|
|
|
|
|
// Key scan debug |
|
|
|
for (uint8_t i=0; i < STROBE_LINES; ++i) { |
|
|
|
for ( uint8_t i = 0; i < STROBE_LINES; ++i ) |
|
|
|
{ |
|
|
|
printHex(usb_keymap[i]); |
|
|
|
print(" "); |
|
|
|
} |
|
|
@@ -1039,16 +908,19 @@ void dumpkeys(void) { |
|
|
|
} |
|
|
|
|
|
|
|
// XXX Will be cleaned up eventually, but this will do for now :P -HaaTa |
|
|
|
for (uint8_t i=0; i < STROBE_LINES; ++i) { |
|
|
|
for(uint8_t j=0; j<MUXES_COUNT; ++j) { |
|
|
|
if ( usb_keymap[i] & (1 << j) ) { |
|
|
|
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 = (i << MUXES_COUNT_XSHIFT) + j; |
|
|
|
|
|
|
|
// Add to the Macro processing buffer |
|
|
|
// Automatically handles converting to a USB code and sending off to the PC |
|
|
|
//bufferAdd( key ); |
|
|
|
|
|
|
|
if(usb_dirty) |
|
|
|
if ( usb_dirty ) |
|
|
|
{ |
|
|
|
printHex( key ); |
|
|
|
print("\n"); |
|
|
@@ -1056,37 +928,47 @@ void dumpkeys(void) { |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
//if(usb_dirty) print("\n"); |
|
|
|
|
|
|
|
usb_keyboard_send(); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void dump(void) { |
|
|
|
|
|
|
|
//#define DEBUG_FULL_SAMPLES_AVERAGES |
|
|
|
#ifdef DEBUG_FULL_SAMPLES_AVERAGES |
|
|
|
if(!dump_count) { // we don't want to debug-out during the measurements. |
|
|
|
|
|
|
|
// we don't want to debug-out during the measurements. |
|
|
|
if ( !dump_count ) |
|
|
|
{ |
|
|
|
// Averages currently set per key |
|
|
|
for(int i =0; i< KEY_COUNT; ++i) { |
|
|
|
if(!(i & 0x0f)) { |
|
|
|
for ( int i = 0; i < KEY_COUNT; ++i ) |
|
|
|
{ |
|
|
|
if ( !(i & 0x0f) ) |
|
|
|
{ |
|
|
|
print("\n"); |
|
|
|
} else if (!(i & 0x07)) { |
|
|
|
} |
|
|
|
else if ( !(i & 0x07) ) |
|
|
|
{ |
|
|
|
print(" "); |
|
|
|
} |
|
|
|
|
|
|
|
print(" "); |
|
|
|
printHex (keys_averages[i]); |
|
|
|
printHex( keys_averages[i] ); |
|
|
|
} |
|
|
|
|
|
|
|
print("\n"); |
|
|
|
|
|
|
|
// Previously read full ADC scans? |
|
|
|
for(int i =0; i< KEY_COUNT; ++i) { |
|
|
|
if(!(i & 0x0f)) { |
|
|
|
for ( int i = 0; i< KEY_COUNT; ++i) |
|
|
|
{ |
|
|
|
if ( !(i & 0x0f) ) |
|
|
|
{ |
|
|
|
print("\n"); |
|
|
|
} else if (!(i & 0x07)) { |
|
|
|
} |
|
|
|
else if ( !(i & 0x07) ) |
|
|
|
{ |
|
|
|
print(" "); |
|
|
|
} |
|
|
|
|
|
|
|
print(" "); |
|
|
|
printHex(full_samples[i]); |
|
|
|
} |
|
|
@@ -1102,7 +984,8 @@ void dump(void) { |
|
|
|
|
|
|
|
// Previously read ADC scans on current strobe |
|
|
|
print(" :"); |
|
|
|
for (uint8_t i=0; i < MUXES_COUNT; ++i) { |
|
|
|
for ( uint8_t i = 0; i < MUXES_COUNT; ++i ) |
|
|
|
{ |
|
|
|
print(" "); |
|
|
|
printHex(full_samples[(cur_strober << MUXES_COUNT_XSHIFT) + i]); |
|
|
|
} |
|
|
@@ -1110,19 +993,16 @@ void dump(void) { |
|
|
|
// Averages current set on current strobe |
|
|
|
print(" :"); |
|
|
|
|
|
|
|
for (uint8_t i=0; i < MUXES_COUNT; ++i) { |
|
|
|
for ( uint8_t i = 0; i < MUXES_COUNT; ++i ) |
|
|
|
{ |
|
|
|
print(" "); |
|
|
|
printHex(keys_averages[(cur_strober << MUXES_COUNT_XSHIFT) + i]); |
|
|
|
} |
|
|
|
|
|
|
|
#endif |
|
|
|
|
|
|
|
//#define DEBUG_DELTA_SAMPLE_THRESHOLD |
|
|
|
#ifdef DEBUG_DELTA_SAMPLE_THRESHOLD |
|
|
|
print("\n"); |
|
|
|
//uint16_t db_delta = 0; |
|
|
|
//uint16_t db_sample = 0; |
|
|
|
//uint16_t db_threshold = 0; |
|
|
|
printHex( db_delta ); |
|
|
|
print(" "); |
|
|
|
printHex( db_sample ); |
|
|
@@ -1132,12 +1012,12 @@ void dump(void) { |
|
|
|
printHex( column ); |
|
|
|
#endif |
|
|
|
|
|
|
|
//#define DEBUG_USB_KEYMAP |
|
|
|
#ifdef DEBUG_USB_KEYMAP |
|
|
|
print("\n "); |
|
|
|
|
|
|
|
// Current keymap values |
|
|
|
for (uint8_t i=0; i < STROBE_LINES; ++i) { |
|
|
|
for ( uint8_t i = 0; i < STROBE_LINES; ++i ) |
|
|
|
{ |
|
|
|
printHex(cur_keymap[i]); |
|
|
|
print(" "); |
|
|
|
} |