Added the averaged initial average as well as problem key rejection
- Any keys that exceed the high average are temporarily disabled - If the sense value goes below the initial average sense, it is re-enabled - Even works if *many* keys are pressed initially - Still needs a bit of detection of consistent high keys that sometimes sneak below the threshold (May be able to have an elastic threshold that could deal with this) - Removed dead code (and redundant calculations)
This commit is contained in:
Jacob Alexander
parent
dd1d3ad362
commit
61e45985c2
@ -39,7 +39,6 @@
|
||||
#define THRESHOLD (THRESHOLD_MV / MV_PER_ADC)
|
||||
|
||||
#define STROBE_SETTLE 1
|
||||
#define MUX_SETTLE 1
|
||||
|
||||
#define TEST_KEY_STROBE (0x05)
|
||||
#define TEST_KEY_MASK (1 << 0)
|
||||
@ -88,15 +87,8 @@
|
||||
#define WARMUP_LOOPS ( 1024 )
|
||||
#define WARMUP_STOP (WARMUP_LOOPS - 1)
|
||||
|
||||
#define SAMPLES 10
|
||||
#define SAMPLE_OFFSET ((SAMPLES) - MUXES_COUNT)
|
||||
#define SAMPLE_CONTROL 3
|
||||
|
||||
// Starting average for keys, per key will adjust during runtime
|
||||
// XXX - A better method is needed to choose this value (i.e. not experimental)
|
||||
// The ideal average is not always found for weak keys if this is set too high...
|
||||
#define DEFAULT_KEY_BASE 0xB0
|
||||
|
||||
#define KEY_COUNT ((MAX_STROBES) * (MUXES_COUNT))
|
||||
|
||||
#define RECOVERY_CONTROL 1
|
||||
@ -140,11 +132,19 @@ volatile uint8_t KeyIndex_BufferUsed;
|
||||
|
||||
|
||||
// TODO dfj variables...needs cleaning up and commenting
|
||||
volatile uint16_t full_av = 0;
|
||||
|
||||
// Variables used to calculate the starting sense value (averaging)
|
||||
uint32_t full_avg = 0;
|
||||
uint32_t high_avg = 0;
|
||||
uint32_t low_avg = 0;
|
||||
|
||||
uint8_t high_count = 0;
|
||||
uint8_t low_count = 0;
|
||||
|
||||
|
||||
uint8_t ze_strober = 0;
|
||||
|
||||
uint16_t samples [SAMPLES];
|
||||
uint16_t samples[MUXES_COUNT];
|
||||
|
||||
uint8_t cur_keymap[MAX_STROBES];
|
||||
|
||||
@ -156,7 +156,8 @@ uint8_t column = 0;
|
||||
|
||||
uint16_t keys_averages_acc[KEY_COUNT];
|
||||
uint16_t keys_averages [KEY_COUNT];
|
||||
uint8_t keys_debounce [KEY_COUNT];
|
||||
uint8_t keys_debounce [KEY_COUNT]; // Contains debounce statistics
|
||||
uint8_t keys_problem [KEY_COUNT]; // Marks keys that should be ignored (determined by averaging at startup)
|
||||
|
||||
uint8_t full_samples[KEY_COUNT];
|
||||
|
||||
@ -174,10 +175,6 @@ uint8_t strobe_map[MAX_STROBES];
|
||||
|
||||
uint8_t dump_count = 0;
|
||||
|
||||
uint16_t db_delta = 0;
|
||||
uint8_t db_sample = 0;
|
||||
uint16_t db_threshold = 0;
|
||||
|
||||
|
||||
|
||||
// ----- Function Declarations -----
|
||||
@ -221,7 +218,6 @@ inline void scan_setup()
|
||||
//#define UNSAVER_STROBE
|
||||
#ifdef KISHSAVER_STROBE
|
||||
total_strobes = 8;
|
||||
//total_strobes = 9;
|
||||
|
||||
strobe_map[0] = 2; // Kishsaver doesn't use strobe 0 and 1
|
||||
strobe_map[1] = 3;
|
||||
@ -232,7 +228,8 @@ inline void scan_setup()
|
||||
strobe_map[6] = 8;
|
||||
strobe_map[7] = 9;
|
||||
// XXX - Disabling for now, not sure how to deal with test points yet (without spamming the debug)
|
||||
//strobe_map[8] = 15; // Test point strobe (3 test points, sense 1, 4, 5)
|
||||
total_strobes = 9;
|
||||
strobe_map[8] = 15; // Test point strobe (3 test points, sense 1, 4, 5)
|
||||
#elif defined(TERMINAL_6110668_STROBE)
|
||||
total_strobes = 16;
|
||||
|
||||
@ -280,16 +277,13 @@ inline void scan_setup()
|
||||
cur_keymap[i] = 0;
|
||||
}
|
||||
|
||||
// Reset debounce table
|
||||
for ( int i = 0; i < KEY_COUNT; ++i )
|
||||
{
|
||||
keys_averages[i] = DEFAULT_KEY_BASE;
|
||||
keys_averages_acc[i] = (DEFAULT_KEY_BASE);
|
||||
|
||||
// Reset debounce table
|
||||
keys_debounce[i] = 0;
|
||||
}
|
||||
|
||||
/** warm things up a bit before we start collecting data, taking real samples. */
|
||||
// Warm things up a bit before we start collecting data, taking real samples.
|
||||
for ( uint8_t i = 0; i < total_strobes; ++i )
|
||||
{
|
||||
sampleColumn( strobe_map[i] );
|
||||
@ -391,15 +385,27 @@ void scan_finishedWithUSBBuffer( uint8_t sentKeys )
|
||||
|
||||
inline void capsense_scan()
|
||||
{
|
||||
// TODO dfj code...needs commenting + cleanup...
|
||||
uint32_t full_av_acc = 0;
|
||||
// Accumulated average used for the next scan
|
||||
uint32_t cur_full_avg = 0;
|
||||
uint32_t cur_high_avg = 0;
|
||||
|
||||
// Reset average counters
|
||||
low_avg = 0;
|
||||
low_count = 0;
|
||||
|
||||
high_count = 0;
|
||||
|
||||
// Scan each of the mapped strobes in the matrix
|
||||
for ( uint8_t strober = 0; strober < total_strobes; ++strober )
|
||||
{
|
||||
uint8_t map_strobe = strobe_map[strober];
|
||||
|
||||
uint8_t tries = 1;
|
||||
while ( tries++ && sampleColumn( map_strobe ) ) { tries &= 0x7; } // don't waste this one just because the last one was poop.
|
||||
|
||||
// Only process sense data if warmup is finished
|
||||
if ( boot_count >= WARMUP_LOOPS )
|
||||
{
|
||||
column = testColumn( map_strobe );
|
||||
|
||||
idle |= column; // if column has any pressed keys, then we are not idle.
|
||||
@ -412,6 +418,7 @@ inline void capsense_scan()
|
||||
}
|
||||
|
||||
idle |= keymap_change; // if any keys have changed inc. released, then we are not idle.
|
||||
}
|
||||
|
||||
if ( error == 0x50 )
|
||||
{
|
||||
@ -422,17 +429,60 @@ inline void capsense_scan()
|
||||
for ( int i = 0; i < MUXES_COUNT; ++i )
|
||||
{
|
||||
// discard sketchy low bit, and meaningless high bits.
|
||||
uint8_t sample = samples[SAMPLE_OFFSET + i] >> 1;
|
||||
uint8_t sample = samples[i] >> 1;
|
||||
full_samples[strobe_line + i] = sample;
|
||||
keys_averages_acc[strobe_line + i] += sample;
|
||||
}
|
||||
|
||||
for ( uint8_t i = SAMPLE_OFFSET; i < ( SAMPLE_OFFSET + MUXES_COUNT ); ++i )
|
||||
// Accumulate 3 total averages (used for determining starting average during warmup)
|
||||
// full_avg - Average of all sampled lines on the previous scan set
|
||||
// cur_full_avg - Average of all sampled lines for this scan set
|
||||
// high_avg - Average of all sampled lines above full_avg on the previous scan set
|
||||
// cur_high_avg - Average of all sampled lines above full_avg
|
||||
// low_avg - Average of all sampled lines below or equal to full_avg
|
||||
if ( boot_count < WARMUP_LOOPS )
|
||||
{
|
||||
full_av_acc += (samples[i]);
|
||||
for ( uint8_t i = 0; i < MUXES_COUNT; ++i )
|
||||
{
|
||||
uint8_t sample = samples[i] >> 1;
|
||||
|
||||
// Sample is high, add it to high avg
|
||||
if ( sample > full_avg )
|
||||
{
|
||||
high_count++;
|
||||
cur_high_avg += sample;
|
||||
}
|
||||
// Sample is low, add it to low avg
|
||||
else
|
||||
{
|
||||
low_count++;
|
||||
low_avg += sample;
|
||||
}
|
||||
|
||||
// If sample is higher than previous high_avg, then mark as "problem key"
|
||||
keys_problem[strobe_line + i] = sample > high_avg ? sample : 0;
|
||||
|
||||
// Prepare for next average
|
||||
cur_full_avg += sample;
|
||||
}
|
||||
}
|
||||
} // for strober
|
||||
|
||||
// Update total sense average (only during warm-up)
|
||||
if ( boot_count < WARMUP_LOOPS )
|
||||
{
|
||||
full_avg = cur_full_avg / (total_strobes * MUXES_COUNT);
|
||||
high_avg = cur_high_avg / high_count;
|
||||
low_avg /= low_count;
|
||||
|
||||
// Update the base average value using the low_avg (best chance of not ignoring a keypress)
|
||||
for ( int i = 0; i < KEY_COUNT; ++i )
|
||||
{
|
||||
keys_averages[i] = low_avg;
|
||||
keys_averages_acc[i] = low_avg;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef VERIFY_TEST_PAD
|
||||
// verify test key is not down.
|
||||
if ( ( cur_keymap[TEST_KEY_STROBE] & TEST_KEY_MASK ) )
|
||||
@ -475,6 +525,38 @@ inline void capsense_scan()
|
||||
info_msg("Warmup finished using ");
|
||||
printInt16( WARMUP_LOOPS );
|
||||
print(" iterations\n");
|
||||
|
||||
// Display the final calculated averages of all the sensed strobes
|
||||
info_msg("Full average (");
|
||||
printInt8( total_strobes * MUXES_COUNT );
|
||||
print("): ");
|
||||
printHex( full_avg );
|
||||
|
||||
print(" High average (");
|
||||
printInt8( high_count );
|
||||
print("): ");
|
||||
printHex( high_avg );
|
||||
|
||||
print(" Low average (");
|
||||
printInt8( low_count );
|
||||
print("): ");
|
||||
printHex( low_avg );
|
||||
print("\n");
|
||||
|
||||
// Display problem keys, and the sense value at the time
|
||||
for ( uint8_t key = 0; key < KEY_COUNT; key++ )
|
||||
{
|
||||
if ( keys_problem[key] )
|
||||
{
|
||||
warn_msg("Problem key detected: ");
|
||||
printHex( key );
|
||||
print(" (");
|
||||
printHex( keys_problem[key] );
|
||||
print(")\n");
|
||||
}
|
||||
}
|
||||
|
||||
info_print("If problem keys were detected, and were being held down, they will be reset as soon as let go");
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -670,20 +752,6 @@ int sampleColumn_8x( uint8_t column, uint16_t * buffer )
|
||||
|
||||
hold_sample(ON);
|
||||
|
||||
#undef MUX_SETTLE
|
||||
|
||||
#if (MUX_SETTLE)
|
||||
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 ) { getADC(); }
|
||||
|
||||
// retrieve current read.
|
||||
buffer[mux] = getADC();
|
||||
}
|
||||
#else
|
||||
uint8_t mux = 0;
|
||||
SET_FULL_MUX(mux);
|
||||
getADC(); // throw away; unknown mux.
|
||||
@ -695,7 +763,6 @@ int sampleColumn_8x( uint8_t column, uint16_t * buffer )
|
||||
mux++;
|
||||
|
||||
} while (mux < 8);
|
||||
#endif
|
||||
|
||||
hold_sample(OFF);
|
||||
recovery(ON);
|
||||
@ -720,7 +787,7 @@ int sampleColumn( uint8_t column )
|
||||
{
|
||||
int rval = 0;
|
||||
|
||||
rval = sampleColumn_8x( column, samples + SAMPLE_OFFSET );
|
||||
rval = sampleColumn_8x( column, samples );
|
||||
|
||||
return rval;
|
||||
}
|
||||
@ -728,27 +795,53 @@ int sampleColumn( uint8_t column )
|
||||
|
||||
uint8_t testColumn( uint8_t strobe )
|
||||
{
|
||||
uint16_t db_delta = 0;
|
||||
uint8_t db_sample = 0;
|
||||
uint16_t db_threshold = 0;
|
||||
|
||||
uint8_t column = 0;
|
||||
uint8_t bit = 1;
|
||||
|
||||
for ( uint8_t mux = 0; mux < MUXES_COUNT; ++mux )
|
||||
{
|
||||
uint16_t delta = keys_averages[(strobe << MUXES_COUNT_XSHIFT) + mux];
|
||||
|
||||
uint8_t key = (strobe << MUXES_COUNT_XSHIFT) + mux;
|
||||
|
||||
// Check if this is a bad key (e.g. test point, or non-existent key)
|
||||
if ( keys_problem[key] )
|
||||
{
|
||||
// If the sample value of the problem key goes below full_avg (overall initial average)
|
||||
// re-enable the key
|
||||
if ( (db_sample = samples[mux] >> 1) < full_avg )
|
||||
{
|
||||
info_msg("Re-enabling problem key: ");
|
||||
printHex( key );
|
||||
print("\n");
|
||||
|
||||
keys_problem[key] = 0;
|
||||
}
|
||||
// Otherwise, don't waste any more cycles processing the problem key
|
||||
else
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// Keypress detected
|
||||
if ( (db_sample = samples[SAMPLE_OFFSET + mux] >> 1) > (db_threshold = threshold) + (db_delta = delta) )
|
||||
// db_sample (uint8_t), discard meaningless high bit, and garbage low bit
|
||||
if ( (db_sample = samples[mux] >> 1) > (db_threshold = threshold) + (db_delta = delta) )
|
||||
{
|
||||
column |= bit;
|
||||
|
||||
// Only register keypresses once the warmup is complete, or not enough debounce info
|
||||
if ( boot_count >= WARMUP_LOOPS && keys_debounce[key] <= DEBOUNCE_THRESHOLD )
|
||||
if ( keys_debounce[key] <= DEBOUNCE_THRESHOLD )
|
||||
{
|
||||
// Add to the Macro processing buffer if debounce criteria met
|
||||
// Automatically handles converting to a USB code and sending off to the PC
|
||||
if ( keys_debounce[key] == DEBOUNCE_THRESHOLD )
|
||||
{
|
||||
#define KEYSCAN_DEBOUNCE_DEBUG
|
||||
//#define KEYSCAN_DEBOUNCE_DEBUG
|
||||
#ifdef KEYSCAN_DEBOUNCE_DEBUG
|
||||
// Debug message
|
||||
print("0x");
|
||||
@ -764,7 +857,7 @@ uint8_t testColumn( uint8_t strobe )
|
||||
|
||||
keys_debounce[key]++;
|
||||
|
||||
//#define KEYSCAN_THRESHOLD_DEBUG
|
||||
#define KEYSCAN_THRESHOLD_DEBUG
|
||||
#ifdef KEYSCAN_THRESHOLD_DEBUG
|
||||
// Debug message
|
||||
// <key> [<strobe>:<mux>] : <sense val> : <delta + threshold> : <margin>
|
||||
@ -887,17 +980,6 @@ void dump(void) {
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef DEBUG_DELTA_SAMPLE_THRESHOLD
|
||||
print("\n");
|
||||
printHex( db_delta );
|
||||
print(" ");
|
||||
printHex( db_sample );
|
||||
print(" ");
|
||||
printHex( db_threshold );
|
||||
print(" ");
|
||||
printHex( column );
|
||||
#endif
|
||||
|
||||
#ifdef DEBUG_USB_KEYMAP
|
||||
print("\n ");
|
||||
|
||||
|
||||
Reference in New Issue
Block a user