di0ib/controller
Archived
1
0
Fork 0
Code Releases Activity

Another dfj code merge.

Browse Source
This commit is contained in:
Jacob Alexander 2013-11-13 23:47:36 -05:00
parent a108dbbbc3
commit a8d8da88e4
1 changed files with 311 additions and 317 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

628
Scan/avr-capsense/scan_loop.c
View File

@ -21,11 +21,27 @@
// ----- Defines ----- // ----- Defines -----
// TODO dfj defines...needs cleaning up and commenting... // TODO dfj defines...needs cleaning up and commenting...
#define THRESHOLD 0x0a #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 MAX_PRESS_DELTA_MV 470
#define THRESHOLD_MV (MAX_PRESS_DELTA_MV >> 1)
//(2560 / (0x3ff/2)) ~= 5
#define MV_PER_ADC 5
// 5
#define THRESHOLD (THRESHOLD_MV / MV_PER_ADC)
#define BUMP_DETECTION 0
#define BUMP_THRESHOLD 0x50 #define BUMP_THRESHOLD 0x50
//((THRESHOLD) * 3) //((THRESHOLD) * 3)
#define BUMP_REST_US 1200 #define BUMP_REST_US 1200
#define STROBE_SETTLE 1
#define MUX_SETTLE 1
#define HYST 1 #define HYST 1
#define HYST_T 0x10 #define HYST_T 0x10
@ -42,7 +58,7 @@
// rough offset voltage: one diode drop, about 50mV = 0x3ff * 50/3560 = 20 // rough offset voltage: one diode drop, about 50mV = 0x3ff * 50/3560 = 20
//#define OFFSET_VOLTAGE 0x14 //#define OFFSET_VOLTAGE 0x14
#define OFFSET_VOLTAGE 0x28 //#define OFFSET_VOLTAGE 0x28
#define RIGHT_JUSTIFY 0 #define RIGHT_JUSTIFY 0
@ -65,6 +81,9 @@
// F0-f7 pins only muxmask. // F0-f7 pins only muxmask.
#define MUX_MASK ((1 << MUX0) | (1 << MUX1) | (1 << MUX2)) #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_1_1 0x1e
#define MUX_GND 0x1f #define MUX_GND 0x1f
@ -93,7 +112,7 @@
#define WARMUP_LOOPS ( 1024 ) #define WARMUP_LOOPS ( 1024 )
#define RECOVERY_US 6 #define RECOVERY_US 2
#define SAMPLES 10 #define SAMPLES 10
@ -102,6 +121,9 @@
//#define SAMPLE_OFFSET 9 //#define SAMPLE_OFFSET 9
#define STROBE_OFFSET 0 #define STROBE_OFFSET 0
#define SAMPLE_CONTROL 3
#define DEFAULT_KEY_BASE 0x95
#define KEY_COUNT ((STROBE_LINES) * (MUXES_COUNT)) #define KEY_COUNT ((STROBE_LINES) * (MUXES_COUNT))
@ -114,15 +136,18 @@
#define RECOVERY_SINK 2 #define RECOVERY_SINK 2
#define RECOVERY_MASK 0x03 #define RECOVERY_MASK 0x03
#define ON 1
#define OFF 0
// mix in 1/4 of the current average to the running average. -> (@mux_mix = 2) // mix in 1/4 of the current average to the running average. -> (@mux_mix = 2)
#define MUX_MIX 2 #define MUX_MIX 2
#define IDLE_COUNT_MASK 0xff #define IDLE_COUNT_MASK 0xff
#define MAX_ICS 8 #define IDLE_COUNT_MAX (IDLE_COUNT_MASK + 1)
#define IDLE_COUNT_SHIFT 8
#define IDLE_COUNT_SHIFT 4
#define KEYS_AVERAGES_MIX 2 #define KEYS_AVERAGES_MIX 2
@ -196,27 +221,28 @@ volatile uint8_t KeyIndex_BufferUsed;
// TODO dfj variables...needs cleaning up and commenting // TODO dfj variables...needs cleaning up and commenting
uint8_t blink = 0; uint8_t blink = 0;
volatile uint8_t idle_count = 1;
volatile uint16_t full_av = 0; volatile uint16_t full_av = 0;
/**/ uint8_t ze_strober = 0; /**/ uint8_t ze_strober = 0;
int16_t samples [SAMPLES]; uint16_t samples [SAMPLES];
//int16_t gsamples [SAMPLES]; //int16_t gsamples [SAMPLES];
/**/ int16_t adc_mux_averages[MUXES_COUNT]; int16_t adc_mux_averages[MUXES_COUNT];
/**/ int16_t adc_strobe_averages[STROBE_LINES]; int16_t adc_strobe_averages[STROBE_LINES];
/**/ uint8_t cur_keymap[STROBE_LINES]; uint8_t cur_keymap[STROBE_LINES];
// /**/ int8_t last_keymap[STROBE_LINES]; // /**/ int8_t last_keymap[STROBE_LINES];
/**/ uint8_t usb_keymap[STROBE_LINES]; uint8_t usb_keymap[STROBE_LINES];
uint16_t keys_down=0;
uint8_t dirty; uint8_t dirty;
uint8_t unstable; uint8_t unstable;
uint8_t usb_dirty; uint8_t usb_dirty;
int16_t threshold = THRESHOLD; uint16_t threshold = THRESHOLD;
uint16_t tests = 0; uint16_t tests = 0;
uint8_t col_a=0; uint8_t col_a=0;
@ -226,32 +252,20 @@ uint8_t col_c=0;
uint8_t column=0; uint8_t column=0;
int16_t keys_averages_acc[KEY_COUNT]; uint16_t keys_averages_acc[KEY_COUNT];
uint16_t keys_averages[KEY_COUNT]; uint16_t keys_averages[KEY_COUNT];
uint16_t keys_averages_acc_count=0;
uint8_t full_samples[KEY_COUNT]; uint8_t full_samples[KEY_COUNT];
/* viable starting biases for near 0.830V offset. and adc PRESCALE 3 // 0x9f...f
0017 0016 001B 001A 0016 0016 000F 000E 001B 001E 001E 0018 0017 0015 000E 001D // #define COUNT_MASK 0x9fff
001B 001A 0016 0016 000F 000E 001C 001B 001E 0018 0017 0015 000E 001D 0024 001F // #define COUNT_HIGH_BIT (INT16_MIN)
0016 0016 000F 000E 001C 001B 001E 001E 0017 0015 000E 001D 0024 001F 0020 001F // TODO: change this to 'booting', then count down.
000F 000E 001C 001B 001E 001E 0018 0017 000E 001D 0024 001F 0020 001F 0020 0017 uint16_t boot_count = 0;
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) uint16_t idle_count=0;
* 77 69 65 5B 50 4E 4C 45 66 53 4D 49 45 3F 3E 35 uint8_t idle = 1;
* 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*/ uint16_t count = 0;
@ -265,6 +279,12 @@ int16_t strobe_averages[STROBE_LINES];
uint8_t dump_count = 0; uint8_t dump_count = 0;
//uint8_t column =0;
uint16_t db_delta = 0;
uint8_t db_sample = 0;
uint16_t db_threshold = 0;
// ----- Function Declarations ----- // ----- Function Declarations -----
@ -329,8 +349,8 @@ inline void scan_setup()
} }
for(int i=0; i< KEY_COUNT; ++i) { for(int i=0; i< KEY_COUNT; ++i) {
keys_averages[i] = 0x40; keys_averages[i] = DEFAULT_KEY_BASE;
keys_averages_acc[i] = (0x400); keys_averages_acc[i] = (DEFAULT_KEY_BASE);
} }
/** 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. */
@ -359,35 +379,48 @@ inline uint8_t scan_loop()
tries = 1; tries = 1;
while (tries++ && sampleColumn(strober)) { tries &= 0x7; } // don't waste this one just because the last one was poop. while (tries++ && sampleColumn(strober)) { tries &= 0x7; } // don't waste this one just because the last one was poop.
column = testColumn(strober); column = testColumn(strober);
idle |= column; // if column has any pressed keys, then we are not idle.
if( column != cur_keymap[strober] && (count >= WARMUP_LOOPS) ) { if( column != cur_keymap[strober] && (count >= WARMUP_LOOPS) ) {
tests++; tests++;
#if 0
tries = 1; tries = 1;
while (tries++ && sampleColumn(strober)) { tries &= 0x7; } // don't waste this one just because the last one was poop. while (tries++ && sampleColumn(strober)) { tries &= 0x7; }
col_a = testColumn(strober); col_a = testColumn(strober);
tries = 1; tries = 1;
while (tries++ && sampleColumn(strober)) { tries &= 0x7; } // don't waste this one just because the last one was poop. while (tries++ && sampleColumn(strober)) { tries &= 0x7; }
col_b = testColumn(strober); col_b = testColumn(strober);
tries = 1; tries = 1;
while (tries++ && sampleColumn(strober)) { tries &= 0x7; } // don't waste this one just because the last one was poop. while (tries++ && sampleColumn(strober)) { tries &= 0x7; }
col_c = testColumn(strober); col_c = testColumn(strober);
if( (col_a == col_b) && (col_b == col_c) && (cur_keymap[strober] != col_a) ) { if( (col_a == col_b) && (col_b == col_c) && (cur_keymap[strober] != col_a) ) {
cur_keymap[strober] = col_a; cur_keymap[strober] = col_a;
usb_dirty = 1; usb_dirty = 1;
} }
#else
cur_keymap[strober] = column;
usb_dirty = 1;
#endif
} }
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); 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) {
full_samples[(strober << MUXES_COUNT_XSHIFT) + i] = samples[SAMPLE_OFFSET + i]; // discard sketchy low bit, and meaningless high bits.
uint8_t sample = samples[SAMPLE_OFFSET + i] >> 1;
full_samples[strobe_line + i] = sample;
keys_averages_acc[strobe_line + i] += sample;
} }
keys_averages_acc_count++;
strobe_averages[strober] = 0; strobe_averages[strober] = 0;
for (uint8_t i = SAMPLE_OFFSET; i < (SAMPLE_OFFSET + MUXES_COUNT); ++i) { for (uint8_t i = SAMPLE_OFFSET; i < (SAMPLE_OFFSET + MUXES_COUNT); ++i) {
@ -395,36 +428,28 @@ inline uint8_t scan_loop()
//samples[i] -= OFFSET_VOLTAGE; // moved to sampleColumn. //samples[i] -= OFFSET_VOLTAGE; // moved to sampleColumn.
full_av_acc += (samples[i]); full_av_acc += (samples[i]);
#ifdef COLLECT_STROBE_AVERAGES
mux_averages[i - SAMPLE_OFFSET] += samples[i]; mux_averages[i - SAMPLE_OFFSET] += samples[i];
strobe_averages[strober] += samples[i]; strobe_averages[strober] += samples[i];
#endif
//samples[i] -= (full_av - HYST_T); //samples[i] -= (full_av - HYST_T);
//++count; //++count;
} }
#ifdef COLLECT_STROBE_AVERAGES
adc_strobe_averages[strober] += strobe_averages[strober] >> 3; adc_strobe_averages[strober] += strobe_averages[strober] >> 3;
adc_strobe_averages[strober] >>= 1; adc_strobe_averages[strober] >>= 1;
/** test if we went negative. */ /** test if we went negative. */
if ((adc_strobe_averages[strober] & 0xFF00) && (count if ((adc_strobe_averages[strober] & 0xFF00) && (boot_count
>= WARMUP_LOOPS)) { >= WARMUP_LOOPS)) {
//count = 0; // TODO : constrain properly.
error = 0xf; error_data = adc_strobe_averages[strober]; error = 0xf; error_data = adc_strobe_averages[strober];
} }
#endif
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 } // for strober
if (count < WARMUP_LOOPS) { #ifdef VERIFY_TEST_PAD
error = 0x0C;
error_data = count;
count++;
}
// verify test key is not down. // verify test key is not down.
if((cur_keymap[TEST_KEY_STROBE] & TEST_KEY_MASK) ) { if((cur_keymap[TEST_KEY_STROBE] & TEST_KEY_MASK) ) {
//count=0; //count=0;
@ -433,58 +458,84 @@ inline uint8_t scan_loop()
error_data += full_samples[TEST_KEY_STROBE * 8]; error_data += full_samples[TEST_KEY_STROBE * 8];
//threshold++; //threshold++;
} }
#endif
#ifdef COLLECT_STROBE_AVERAGES
// calc mux averages. // calc mux averages.
if (count < WARMUP_LOOPS) { if (boot_count < WARMUP_LOOPS) {
full_av += (full_av_acc >> (7)); full_av += (full_av_acc >> (7));
full_av >>= 1; full_av >>= 1;
//full_av = full_av_acc / count; //full_av = full_av_acc / count;
full_av_acc = 0; full_av_acc = 0;
for (int i=0; i < MUXES_COUNT; ++i) {
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)
adc_mux_averages[i] = (adc_mux_averages[i] << MUX_MIX) - adc_mux_averages[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_averages[i] >> 4);
adc_mux_averages[i] >>= MUX_MIX; adc_mux_averages[i] >>= MUX_MIX;
mux_averages[i] = 0; mux_averages[i] = 0;
} }
} }
#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.
* */
idle_count++; idle_count++;
idle_count &= IDLE_COUNT_MASK; idle_count &= IDLE_COUNT_MASK;
if (/*usb_dirty &&*/ (count >= WARMUP_LOOPS) ) { idle = idle && !keys_down;
for (int i=0; i<STROBE_LINES; ++i) {
usb_keymap[i] = cur_keymap[i]; 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) {
usb_keymap[i] = cur_keymap[i];
}
dumpkeys();
usb_dirty=0;
memset(((void *)keys_averages_acc), 0, (size_t)(KEY_COUNT * sizeof (uint16_t)));
keys_averages_acc_count = 0;
idle_count = 0;
idle = 0;
_delay_us(100);
} }
dumpkeys(); if (!idle_count) {
usb_dirty=0; if(idle) {
_delay_ms(2); // aggregate
} 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];
if (count < WARMUP_LOOPS) { av = (av << KEYS_AVERAGES_MIX_SHIFT) - av + acc;
for (uint8_t i = 0; i < KEY_COUNT; ++i) { av >>= KEYS_AVERAGES_MIX_SHIFT;
uint16_t acc = keys_averages_acc[i];
uint32_t av = keys_averages[i];
av = av + av + av + acc; keys_averages[i] = av;
av >>= 2; keys_averages_acc[i] = 0;
}
}
keys_averages_acc_count = 0;
keys_averages[i] = av; if(boot_count >= WARMUP_LOOPS) {
keys_averages_acc[i] = 0; dump();
} }
}
sampleColumn(0x0); // to resync us if we dumped a mess 'o text.
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.
} }
@ -542,8 +593,7 @@ void scan_finishedWithUSBBuffer( uint8_t sentKeys )
} }
void void _delay_loop(uint8_t __count)
_delay_loop(uint8_t __count)
{ {
__asm__ volatile ( __asm__ volatile (
"1: dec %0" "\n\t" "1: dec %0" "\n\t"
@ -606,7 +656,6 @@ void setup_ADC (void) {
ADCSRA |= (1 << ADEN); // ADC enable ADCSRA |= (1 << ADEN); // ADC enable
ADCSRA |= (1 << ADSC); // start conversions q ADCSRA |= (1 << ADSC); // start conversions q
} }
@ -617,15 +666,23 @@ void recovery(uint8_t on) {
DDRB &= ~(1 << RECOVERY_SOURCE); // SOURCE high imp DDRB &= ~(1 << RECOVERY_SOURCE); // SOURCE high imp
if(on) { if(on) {
DDRB |= (1 << RECOVERY_SINK); // SINK pull // set strobes to sink to gnd.
DDRC |= C_MASK;
DDRD |= D_MASK;
DDRE |= E_MASK;
PORTC &= ~C_MASK;
PORTD &= ~D_MASK;
PORTE &= ~E_MASK;
DDRB |= (1 << RECOVERY_SINK); // SINK pull
PORTB |= (1 << RECOVERY_CONTROL); PORTB |= (1 << RECOVERY_CONTROL);
PORTB |= (1 << RECOVERY_SOURCE); // SOURCE high PORTB |= (1 << RECOVERY_SOURCE); // SOURCE high
DDRB |= (1 << RECOVERY_SOURCE); DDRB |= (1 << RECOVERY_SOURCE);
} else { } else {
_delay_loop(10); // _delay_loop(10);
PORTB &= ~(1 << RECOVERY_CONTROL); PORTB &= ~(1 << RECOVERY_CONTROL);
DDRB &= ~(1 << RECOVERY_SOURCE); DDRB &= ~(1 << RECOVERY_SOURCE);
@ -637,6 +694,17 @@ void recovery(uint8_t on) {
} }
void hold_sample(uint8_t on) {
if (!on) {
PORTB |= (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); PORTC &= ~(C_MASK);
@ -729,193 +797,168 @@ void strobe_w(uint8_t strobe_num) {
break; break;
} }
}
#if 0 #if 0 // New code from dfj -> still needs redoing for kishsaver and autodetection of strobes
int sampleColumn_i(uint8_t column, uint8_t muxes, int16_t * buffer) { #ifdef SHORT_C
strobe_num = 15 - strobe_num;
#endif
// ensure all probe lines are driven low, and chill for recovery delay. #ifdef SINGLE_COLUMN_TEST
PORTC &= ~C_MASK; strobe_num = 5;
PORTD &= ~D_MASK; #endif
PORTE &= ~E_MASK;
recovery(1);
_delay_us(RECOVERY_US);
recovery(0);
//uint8_t index = 0; switch(strobe_num) {
for (uint8_t i=0; i<8; ++i) { case 0: PORTD |= (1 << 0); DDRD &= ~(1 << 0); break;
if(muxes & (1 << i)) { case 1: PORTD |= (1 << 1); DDRD &= ~(1 << 1); break;
buffer[index++] = i; case 2: PORTD |= (1 << 2); DDRD &= ~(1 << 2); break;
} case 3: PORTD |= (1 << 3); DDRD &= ~(1 << 3); break;
case 4: PORTD |= (1 << 4); DDRD &= ~(1 << 4); break;
case 5: PORTD |= (1 << 5); DDRD &= ~(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); DDRD &= ~(1 << 6); break;
case 7: PORTD |= (1 << 7); DDRD &= ~(1 << 7); break;
case 8: PORTE |= (1 << 0); DDRE &= ~(1 << 0); break;
case 9: PORTE |= (1 << 1); DDRE &= ~(1 << 1); break;
case 10: PORTC |= (1 << 0); DDRC &= ~(1 << 0); break;
case 11: PORTC |= (1 << 1); DDRC &= ~(1 << 1); break;
case 12: PORTC |= (1 << 2); DDRC &= ~(1 << 2); break;
case 13: PORTC |= (1 << 3); DDRC &= ~(1 << 3); break;
case 14: PORTC |= (1 << 4); DDRC &= ~(1 << 4); break;
case 15: PORTC |= (1 << 5); DDRC &= ~(1 << 5); break;
case 16: PORTC |= (1 << 6); DDRC &= ~(1 << 6); break;
case 17: PORTC |= (1 << 7); DDRC &= ~(1 << 7); break;
#endif
#endif
#endif
default:
break;
} }
SET_FULL_MUX(MUX_1_1); // crap sample will use this. #endif
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.
//ADC; // 1st sample, icky. XXX Not sure if the compiler throws this away, but less compiler warnings -HaaTa
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
*
* */
}
inline uint16_t getADC() {
ADCSRA |= (1 << ADIF); // clear int flag by writing 1. ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
//wait for last read to complete. //wait for last read to complete.
while (! (ADCSRA & (1 << ADIF))); while (! (ADCSRA & (1 << ADIF)));
sample = ADC; // throw away strobe'd value. return ADC; // return 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.
//ADC; // throw away warmup value.
/*
ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
while (! (ADCSRA & (1 << ADIF)));
//sample = ADC; // throw away warmup value.
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;
} }
#endif
int sampleColumn_k(uint8_t column, int16_t * buffer) { int sampleColumn_8x(uint8_t column, uint16_t * buffer) {
// ensure all probe lines are driven low, and chill for recovery delay. // ensure all probe lines are driven low, and chill for recovery delay.
uint16_t sample; uint16_t sample;
ADCSRA |= (1 << ADEN) | (1 << ADSC); // enable and start conversions ADCSRA |= (1 << ADEN) | (1 << ADSC); // enable and start conversions
ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
// sync up with adc clock: // sync up with adc clock:
while (! (ADCSRA & (1 << ADIF))); // wait until ready. //sample = getADC();
//ADC; // throw it away. // XXX Not sure if the compiler throws this away, but less compiler warnings -HaaTa
sample = ADC; // throw it away.
PORTC &= ~C_MASK;
PORTD &= ~D_MASK;
PORTE &= ~E_MASK;
PORTF = 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();
}
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) {
PORTC &= ~C_MASK;
PORTD &= ~D_MASK;
PORTE &= ~E_MASK;
SET_FULL_MUX(mux); // our sample will use this SET_FULL_MUX(mux); // our sample will use this
// wait for mux to settle.
for(uint8_t i=0; i < 2; ++i) { for(uint8_t i=0; i < MUX_SETTLE; ++i) {
ADCSRA |= (1 << ADIF); // clear int flag by writing 1. sample = getADC();
//wait for last read to complete.
while (! (ADCSRA & (1 << ADIF)));
sample = ADC; // throw away strobe'd value.
//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.
//ADC; // throw away strobe'd value.
ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
while (! (ADCSRA & (1 << ADIF)));
// retrieve current read. // retrieve current read.
buffer[mux] = ADC - OFFSET_VOLTAGE; buffer[mux] = getADC();// - OFFSET_VOLTAGE;
recovery(1);
} }
#else
uint8_t mux=0;
SET_FULL_MUX(mux);
sample = 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;
mux++;
} while (mux < 8);
#endif
hold_sample(OFF);
recovery(ON);
// turn off adc. // turn off adc.
ADCSRA &= ~(1 << ADEN); ADCSRA &= ~(1 << ADEN);
// pull all columns' probe-lines low. // pull all columns' strobe-lines low.
DDRC |= C_MASK;
DDRD |= D_MASK;
DDRE |= E_MASK;
PORTC &= ~C_MASK; PORTC &= ~C_MASK;
PORTD &= ~D_MASK; PORTD &= ~D_MASK;
PORTE &= ~E_MASK; PORTE &= ~E_MASK;
// recovery(1);
return 0; return 0;
} }
@ -924,14 +967,10 @@ int sampleColumn_k(uint8_t column, int16_t * buffer) {
int sampleColumn(uint8_t column) { int sampleColumn(uint8_t column) {
int rval = 0; int rval = 0;
/* //rval = sampleColumn_k(column, samples+SAMPLE_OFFSET);
sampleColumn_i(column, 0x0f, samples+SAMPLE_OFFSET); rval = sampleColumn_8x(column, samples+SAMPLE_OFFSET);
sampleColumn_i(column, 0xf0, samples+SAMPLE_OFFSET + 4 );
*/
rval = sampleColumn_k(column, samples+SAMPLE_OFFSET); #if (BUMP_DETECTION)
//for(uint8_t i=0; i<1; ++i) { // TODO REMOVEME
for(uint8_t i=0; i<8; ++i) { for(uint8_t i=0; i<8; ++i) {
if(samples[SAMPLE_OFFSET + i] - adc_mux_averages[i] > BUMP_THRESHOLD) { if(samples[SAMPLE_OFFSET + i] - adc_mux_averages[i] > BUMP_THRESHOLD) {
// was a hump // was a hump
@ -943,34 +982,36 @@ int sampleColumn(uint8_t column) {
return rval; return rval;
} }
} }
#endif
return rval; return rval;
} }
uint8_t testColumn(uint8_t strobe) { uint8_t testColumn(uint8_t strobe) {
uint8_t column = 0; uint8_t column = 0;
uint8_t bit = 1; 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]; uint16_t delta = keys_averages[(strobe << MUXES_COUNT_XSHIFT) + i];
if ((int16_t)samples[SAMPLE_OFFSET + i] > threshold + delta) { if ((db_sample = samples[SAMPLE_OFFSET + i] >> 1) > (db_threshold = threshold) + (db_delta = delta)) {
column |= bit; column |= bit;
} }
bit <<= 1; bit <<= 1;
} }
return column; return column;
} }
void dumpkeys(void) { void dumpkeys(void) {
//print(" \n"); //print(" \n");
if(error) { if(error) {
/*
if (count >= WARMUP_LOOPS && error) { if (count >= WARMUP_LOOPS && error) {
dump(); dump();
} }
*/
// Key scan debug // 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]); printHex(usb_keymap[i]);
print(" "); print(" ");
@ -983,7 +1024,6 @@ void dumpkeys(void) {
printHex(error_data); printHex(error_data);
error_data = 0; error_data = 0;
print(" : " NL); print(" : " NL);
*/
} }
// XXX Will be cleaned up eventually, but this will do for now :P -HaaTa // XXX Will be cleaned up eventually, but this will do for now :P -HaaTa
@ -1013,6 +1053,8 @@ void dumpkeys(void) {
void dump(void) { 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. if(!dump_count) { // we don't want to debug-out during the measurements.
// Averages currently set per key // Averages currently set per key
@ -1023,7 +1065,6 @@ void dump(void) {
print(" "); print(" ");
} }
print(" "); print(" ");
//printHex (keys_averages[(i >> MUXES_COUNT_XSHIFT) + (i & STROBE_LINES_MASK) ]);
printHex (keys_averages[i]); printHex (keys_averages[i]);
} }
@ -1037,20 +1078,18 @@ void dump(void) {
print(" "); print(" ");
} }
print(" "); print(" ");
//printHex (keys_averages[(i >> MUXES_COUNT_XSHIFT) + (i & STROBE_LINES_MASK) ]);
//printHex (keys_averages_acc[i]);
printHex(full_samples[i]); printHex(full_samples[i]);
} }
} }
#endif
#ifdef DEBUG_STROBE_SAMPLES_AVERAGES
// Per strobe information // Per strobe information
// uint8_t cur_strober = 0xe;
uint8_t cur_strober = ze_strober; uint8_t cur_strober = ze_strober;
print("\n"); print("\n");
printHex(cur_strober); printHex(cur_strober);
//print(": ");
#if 1
// Previously read ADC scans on current strobe // Previously read ADC scans on current strobe
print(" :"); print(" :");
for (uint8_t i=0; i < MUXES_COUNT; ++i) { for (uint8_t i=0; i < MUXES_COUNT; ++i) {
@ -1060,88 +1099,43 @@ void dump(void) {
// Averages current set on current strobe // Averages current set on current strobe
print(" :"); print(" :");
// printHex(threshold);
for (uint8_t i=0; i < MUXES_COUNT; ++i) { for (uint8_t i=0; i < MUXES_COUNT; ++i) {
print(" "); print(" ");
printHex(keys_averages[(cur_strober << MUXES_COUNT_XSHIFT) + i]); printHex(keys_averages[(cur_strober << MUXES_COUNT_XSHIFT) + i]);
} }
#endif #endif
/*
for (uint8_t i=0; i< SAMPLES; ++i) {
print(" ");
printHex(samples[i]);
//printHex(ADC);
}*/
//print(" : ");
//dPrint((was_active)?" ":"*");
//printHex(keymap[TEST_KEY_STROBE] & TEST_KEY_MASK); #ifdef DEBUG_DELTA_SAMPLE_THRESHOLD
/*print(" "); */ print("\n");
//printHex(keymap[TEST_KEY_STROBE]); //uint16_t db_delta = 0;
//uint16_t db_sample = 0;
//uint16_t db_threshold = 0;
printHex( db_delta );
print(" ");
printHex( db_sample );
print(" ");
printHex( db_threshold );
print(" ");
printHex( column );
#endif
#define DEBUG_USB_KEYMAP
//print("\n"); #ifdef DEBUG_USB_KEYMAP
//print(":");
//printHex(full_av);
//printHex(count);
//print(" : ");
print("\n "); print("\n ");
// Current keymap values // 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]); printHex(cur_keymap[i]);
print(" "); print(" ");
//print(" ");
} }
#endif
//print(": ");
//printHex(adc_strobe_averages[ze_strober]);
//print(" ");
/* Already printing this above...
for (uint8_t i=0; i < MUXES_COUNT; ++i) {
print(" ");
//printHex(adc_mux_averages[i] + adc_strobe_averages[ze_strober] - full_av);
//printHex((adc_mux_averages[i] + adc_strobe_averages[ze_strober]) >> 1);
//printHex((adc_mux_averages[i] * 3 + adc_strobe_averages[ze_strober]) >> 2);
//printHex(adc_mux_averages[i] + threshold);
//printHex(gsamples[i + SAMPLE_OFFSET] - (adc_mux_averages[i] + threshold) + 0x100);
//printHex(keys_averages[(ze_strober << MUXES_COUNT_XSHIFT) + i] + (uint8_t)threshold);
printHex(keys_averages[(ze_strober << MUXES_COUNT_XSHIFT) + i]);
}
*/
/* Being printed in dumpkeys()
if(error) {
print(" ");
printHex(error);
print(" ");
printHex(error_data);
error = 0;
error_data = 0;
}
//print("\n");
*/
ze_strober++; ze_strober++;
ze_strober &= 0xf; ze_strober &= 0xf;
dump_count++; dump_count++;
dump_count &= 0x0f; dump_count &= 0x0f;
//ze_strobe = (1 << (ze_strober ) );
//printHex(ADCSRA);
//print(" ");
//print("\n");
} }