1 /* Copyright (C) 2011-2013 by Joseph Makuch
2 * Additions by Jacob Alexander (2013)
4 * dfj, put whatever license here you want -HaaTa
7 // ----- Includes -----
10 #include <Lib/ScanLib.h>
17 #include "scan_loop.h"
21 // ----- Defines -----
23 // TODO dfj defines...needs cleaning up and commenting...
24 #define THRESHOLD 0x0a
25 #define BUMP_THRESHOLD 0x50
27 #define BUMP_REST_US 1200
32 #define TEST_KEY_STROBE (0x05)
33 #define TEST_KEY_MASK (1 << 0)
37 /** Whether to use all of D and C, vs using E0, E1 instead of D6, D7,
38 * or alternately all of D, and E0,E1 and C0,..5 */
43 // rough offset voltage: one diode drop, about 50mV = 0x3ff * 50/3560 = 20
44 //#define OFFSET_VOLTAGE 0x14
45 #define OFFSET_VOLTAGE 0x28
48 #define RIGHT_JUSTIFY 0
49 #define LEFT_JUSTIFY (0xff)
51 // set left or right justification here:
52 #define JUSTIFY_ADC RIGHT_JUSTIFY
54 #define ADLAR_MASK (1 << ADLAR)
56 #define ADLAR_BITS ((ADLAR_MASK) & (JUSTIFY_ADC))
57 #else // defaults to right justification.
63 #define FULL_MUX_MASK ((1 << MUX0) | (1 << MUX1) | (1 << MUX2) | (1 << MUX3) | (1 << MUX4))
65 // F0-f7 pins only muxmask.
66 #define MUX_MASK ((1 << MUX0) | (1 << MUX1) | (1 << MUX2))
72 // set ADC clock prescale
73 #define PRESCALE_MASK ((1 << ADPS0) | (1 << ADPS1) | (1 << ADPS2))
74 #define PRESCALE_SHIFT (ADPS0)
78 #ifdef EXTENDED_STROBE
80 #define STROBE_LINES 18
84 #define STROBE_LINES 16
88 #define STROBE_LINES_XSHIFT 4
89 #define STROBE_LINES_MASK 0x0f
91 #define MUXES_COUNT_XSHIFT 3
92 #define MUXES_MASK 0x7
94 #define WARMUP_LOOPS ( 1024 )
101 #define SAMPLE_OFFSET ((SAMPLES) - MUXES_COUNT)
102 //#define SAMPLE_OFFSET 9
103 #define STROBE_OFFSET 0
106 #define KEY_COUNT ((STROBE_LINES) * (MUXES_COUNT))
111 #define RECOVERY_CONTROL 1
113 #define RECOVERY_SOURCE 0
114 #define RECOVERY_SINK 2
115 #define RECOVERY_MASK 0x03
118 // mix in 1/4 of the current average to the running average. -> (@mux_mix = 2)
122 #define IDLE_COUNT_MASK 0xff
125 #define IDLE_COUNT_SHIFT 4
126 #define KEYS_AVERAGES_MIX 2
131 #define D_MASK (0xff)
134 #define E_MASK (0x00)
137 #define C_MASK (0xff)
143 #define D_MASK (0x3f)
146 #define E_MASK (0x03)
149 #define C_MASK (0xff)
155 #define D_MASK (0xff)
158 #define E_MASK (0x03)
161 #define C_MASK (0xff)
171 // ----- Macros -----
173 // Make sure we haven't overflowed the buffer
174 #define bufferAdd(byte) \
175 if ( KeyIndex_BufferUsed < KEYBOARD_BUFFER ) \
176 KeyIndex_Buffer[KeyIndex_BufferUsed++] = byte
179 // TODO dfj macros...needs cleaning up and commenting...
180 #define STROBE_CASE(SC_CASE, SC_REG_A) case (SC_CASE): PORT##SC_REG_A = \
181 (( (PORT##SC_REG_A) & ~(1 << (SC_CASE - SC_REG_A##_SHIFT)) ) | (1 << (SC_CASE - SC_REG_A##_SHIFT)))
183 #define SET_MUX(X) ((ADMUX) = (((ADMUX) & ~(MUX_MASK)) | ((X) & (MUX_MASK))))
184 #define SET_FULL_MUX(X) ((ADMUX) = (((ADMUX) & ~(FULL_MUX_MASK)) | ((X) & (FULL_MUX_MASK))))
190 // ----- Variables -----
192 // Buffer used to inform the macro processing module which keys have been detected as pressed
193 volatile uint8_t KeyIndex_Buffer[KEYBOARD_BUFFER];
194 volatile uint8_t KeyIndex_BufferUsed;
197 // TODO dfj variables...needs cleaning up and commenting
199 volatile uint8_t idle_count = 1;
200 volatile uint16_t full_av = 0;
202 /**/ uint8_t ze_strober = 0;
204 int16_t samples [SAMPLES];
206 //int16_t gsamples [SAMPLES];
208 /**/ int16_t adc_mux_averages[MUXES_COUNT];
209 /**/ int16_t adc_strobe_averages[STROBE_LINES];
212 /**/ uint8_t cur_keymap[STROBE_LINES];
213 // /**/ int8_t last_keymap[STROBE_LINES];
214 /**/ uint8_t usb_keymap[STROBE_LINES];
219 int16_t threshold = THRESHOLD;
229 int16_t keys_averages_acc[KEY_COUNT];
230 uint16_t keys_averages[KEY_COUNT];
232 uint8_t full_samples[KEY_COUNT];
234 /* viable starting biases for near 0.830V offset. and adc PRESCALE 3
235 0017 0016 001B 001A 0016 0016 000F 000E 001B 001E 001E 0018 0017 0015 000E 001D
236 001B 001A 0016 0016 000F 000E 001C 001B 001E 0018 0017 0015 000E 001D 0024 001F
237 0016 0016 000F 000E 001C 001B 001E 001E 0017 0015 000E 001D 0024 001F 0020 001F
238 000F 000E 001C 001B 001E 001E 0018 0017 000E 001D 0024 001F 0020 001F 0020 0017
239 001C 001B 001E 001E 0018 0017 0015 000E 0024 001F 0020 001F 0020 0017 0010 001D
240 001E 001E 0018 0017 0015 000E 001D 0024 0020 001F 0020 0017 0010 001D 0024 0021
241 0018 0017 0015 000E 001D 0024 001F 0020 0020 0017 0010 001D 0024 0021 0021 0021
242 0015 000E 001D 0024 001F 0020 001F 0020 0010 001D 0024 0021 0021 0021 0021 0018
245 /*** starting bias relative to fixed offset estimate of 820mV (0x50)
246 * 77 69 65 5B 50 4E 4C 45 66 53 4D 49 45 3F 3E 35
247 * 68 54 4F 49 45 40 3F 34 74 66 5F 56 4E 4D 4C 3F
248 * 6D 5D 53 4C 49 46 45 38 6D 5A 53 4E 49 48 45 3E
249 * 6F 5D 56 4E 4B 48 48 3A 6D 5C 54 4E 48 48 45 37
250 * 75 68 5F 57 4F 4D 4C 3F 60 4E 48 41 3C 3C 39 2F
251 * 65 53 4E 49 41 3F 3E 34 65 54 4E 49 43 3F 3E 34
252 * 60 51 4A 45 3F 3E 3C 30 57 4C 45 3E 3B 37 37 2E
253 * 64 4E 48 44 3C 3B 39 2F 5D 4F 48 45 3E 3C 3B 30
256 /*volatile*/ uint16_t count = 0;
258 /*volatile*/ uint8_t error = 0;
259 uint16_t error_data = 0;
262 int16_t mux_averages[MUXES_COUNT];
263 int16_t strobe_averages[STROBE_LINES];
265 uint8_t dump_count = 0;
269 // ----- Function Declarations -----
272 void dumpkeys( void );
274 void recovery( uint8_t on );
276 int sampleColumn ( uint8_t column );
277 //int sampleColumn_i( uint8_t column, uint8_t muxes, int16_t * buffer); // XXX Not currently used
278 int sampleColumn_k( uint8_t column, int16_t *buffer );
280 void setup_ADC( void );
282 void strobe_w( uint8_t strobe_num );
284 uint8_t testColumn( uint8_t strobe );
288 // ----- Functions -----
290 // Initial setup for cap sense controller
291 inline void scan_setup()
293 // TODO dfj code...needs cleanup + commenting...
296 // Configure timer 0 to generate a timer overflow interrupt every
297 // 256*1024 clock cycles, or approx 61 Hz when using 16 MHz clock
298 // This demonstrates how to use interrupts to implement a simple
299 // inactivity timeout.
302 //TIMSK0 = (1<<TOIE0);
314 //uint16_t strobe = 1;
317 // TODO all this code should probably be in scan_resetKeyboard
318 for (int i=0; i< STROBE_LINES; ++i) {
320 //last_keymap[i] = 0;
324 for(int i=0; i < MUXES_COUNT; ++i) {
325 adc_mux_averages[i] = 0x20; // experimentally determined.
327 for(int i=0; i < STROBE_LINES; ++i) {
328 adc_strobe_averages[i] = 0x20; // yup.
331 for(int i=0; i< KEY_COUNT; ++i) {
332 keys_averages[i] = 0x40;
333 keys_averages_acc[i] = (0x400);
336 /** warm things up a bit before we start collecting data, taking real samples. */
337 for(uint8_t i = 0; i< STROBE_LINES; ++i) {
342 // Reset the keyboard before scanning, we might be in a wierd state
343 // Also sets the KeyIndex_BufferUsed to 0
344 scan_resetKeyboard();
348 // Main Detection Loop
349 // This is where the important stuff happens
350 inline uint8_t scan_loop()
352 // TODO dfj code...needs commenting + cleanup...
354 uint32_t full_av_acc = 0;
356 for (strober = 0; strober < STROBE_LINES; ++strober) {
360 while (tries++ && sampleColumn(strober)) { tries &= 0x7; } // don't waste this one just because the last one was poop.
361 column = testColumn(strober);
363 if( column != cur_keymap[strober] && (count >= WARMUP_LOOPS) ) {
367 while (tries++ && sampleColumn(strober)) { tries &= 0x7; } // don't waste this one just because the last one was poop.
368 col_a = testColumn(strober);
371 while (tries++ && sampleColumn(strober)) { tries &= 0x7; } // don't waste this one just because the last one was poop.
372 col_b = testColumn(strober);
375 while (tries++ && sampleColumn(strober)) { tries &= 0x7; } // don't waste this one just because the last one was poop.
376 col_c = testColumn(strober);
378 if( (col_a == col_b) && (col_b == col_c) && (cur_keymap[strober] != col_a) ) {
379 cur_keymap[strober] = col_a;
385 error_data |= (((uint16_t)strober) << 12);
388 for(int i=0; i<MUXES_COUNT; ++i) {
389 full_samples[(strober << MUXES_COUNT_XSHIFT) + i] = samples[SAMPLE_OFFSET + i];
392 strobe_averages[strober] = 0;
393 for (uint8_t i = SAMPLE_OFFSET; i < (SAMPLE_OFFSET + MUXES_COUNT); ++i) {
394 //samples[i] -= samples[i-SAMPLE_OFFSET]; // av; // + full_av); // -something.
395 //samples[i] -= OFFSET_VOLTAGE; // moved to sampleColumn.
397 full_av_acc += (samples[i]);
398 mux_averages[i - SAMPLE_OFFSET] += samples[i];
399 strobe_averages[strober] += samples[i];
400 //samples[i] -= (full_av - HYST_T);
404 adc_strobe_averages[strober] += strobe_averages[strober] >> 3;
405 adc_strobe_averages[strober] >>= 1;
407 /** test if we went negative. */
408 if ((adc_strobe_averages[strober] & 0xFF00) && (count
410 //count = 0; // TODO : constrain properly.
411 error = 0xf; error_data = adc_strobe_averages[strober];
414 uint8_t strobe_line = strober << MUXES_COUNT_XSHIFT;
415 for (int i = 0; i < MUXES_COUNT; ++i) {
416 keys_averages_acc[strobe_line + i]
417 += samples[SAMPLE_OFFSET + i];
422 if (count < WARMUP_LOOPS) {
428 // verify test key is not down.
429 if((cur_keymap[TEST_KEY_STROBE] & TEST_KEY_MASK) ) {
432 error_data = cur_keymap[TEST_KEY_STROBE] << 8;
433 error_data += full_samples[TEST_KEY_STROBE * 8];
437 // calc mux averages.
438 if (count < WARMUP_LOOPS) {
439 full_av += (full_av_acc >> (7));
441 //full_av = full_av_acc / count;
443 for (int i=0; i < MUXES_COUNT; ++i) {
445 adc_mux_averages[i] = (adc_mux_averages[i] << MUX_MIX) - adc_mux_averages[i];
446 adc_mux_averages[i] += (mux_averages[i] >> 4);
447 adc_mux_averages[i] >>= MUX_MIX;
455 idle_count &= IDLE_COUNT_MASK;
457 if (/*usb_dirty &&*/ (count >= WARMUP_LOOPS) ) {
458 for (int i=0; i<STROBE_LINES; ++i) {
459 usb_keymap[i] = cur_keymap[i];
467 if (count < WARMUP_LOOPS) {
468 for (uint8_t i = 0; i < KEY_COUNT; ++i) {
469 uint16_t acc = keys_averages_acc[i];
470 uint32_t av = keys_averages[i];
472 av = av + av + av + acc;
475 keys_averages[i] = av;
476 keys_averages_acc[i] = 0;
483 for (int i=0; i< KEY_COUNT; ++i) {
484 keys_averages_acc[i] = 0;
487 sampleColumn(0x0); // to resync us if we dumped a mess 'o text.
491 // Return non-zero if macro and USB processing should be delayed
492 // Macro processing will always run if returning 0
493 // USB processing only happens once the USB send timer expires, if it has not, scan_loop will be called
494 // after the macro processing has been completed
500 void scan_resetKeyboard( void )
502 // Empty buffer, now that keyboard has been reset
503 KeyIndex_BufferUsed = 0;
507 // Send data to keyboard
508 // NOTE: Only used for converters, since the scan module shouldn't handle sending data in a controller
509 uint8_t scan_sendData( uint8_t dataPayload )
515 // Reset/Hold keyboard
516 // NOTE: Only used for converters, not needed for full controllers
517 void scan_lockKeyboard( void )
521 // NOTE: Only used for converters, not needed for full controllers
522 void scan_unlockKeyboard( void )
527 // Signal KeyIndex_Buffer that it has been properly read
528 // NOTE: Only really required for implementing "tricks" in converters for odd protocols
529 void scan_finishedWithBuffer( uint8_t sentKeys )
531 // Convenient place to clear the KeyIndex_Buffer
532 KeyIndex_BufferUsed = 0;
537 // Signal KeyIndex_Buffer that it has been properly read and sent out by the USB module
538 // NOTE: Only really required for implementing "tricks" in converters for odd protocols
539 void scan_finishedWithUSBBuffer( uint8_t sentKeys )
546 _delay_loop(uint8_t __count)
557 void setup_ADC (void) {
558 // disable adc digital pins.
559 DIDR1 |= (1 << AIN0D) | (1<<AIN1D); // set disable on pins 1,0.
560 //DIDR0 = 0xff; // disable all. (port F, usually). - testing w/o disable.
563 uint8_t mux = 0 & 0x1f; // 0 == first. // 0x1e = 1.1V ref.
565 // 0 = external aref 1,1 = 2.56V internal ref
566 uint8_t aref = ((1 << REFS1) | (1 << REFS0)) & ((1 << REFS1) | (1 << REFS0));
567 // uint8_t adlar = 0xff & (1 << ADLAR); // 1 := left justify bits, 0 := right
568 uint8_t adate = (1 << ADATE) & (1 << ADATE); // trigger enable
569 uint8_t trig = 0 & ((1 << ADTS0) | (1 << ADTS1) | (1 << ADTS2)); // 0 = free running
570 // ps2, ps1 := /64 ( 2^6 ) ps2 := /16 (2^4), ps1 := 4, ps0 :=2, PS1,PS0 := 8 (2^8)
571 uint8_t prescale = ( ((PRESCALE) << PRESCALE_SHIFT) & PRESCALE_MASK ); // 001 == 2^1 == 2
572 uint8_t hispeed = (1 << ADHSM);
573 uint8_t en_mux = (1 << ACME);
575 //ADCSRA = (ADCSRA & ~PRESCALES) | ((1 << ADPS1) | (1 << ADPS2)); // 2, 1 := /64 ( 2^6 )
576 //ADCSRA = (ADCSRA & ~PRESCALES) | ((1 << ADPS0) | (1 << ADPS2)); // 2, 0 := /32 ( 2^5 )
577 //ADCSRA = (ADCSRA & ~PRESCALES) | ((1 << ADPS2)); // 2 := /16 ( 2^4 )
579 ADCSRA = (1 << ADEN) | prescale; // ADC enable
582 //ADMUX |= ((1 << REFS1) | (1 << REFS0)); // 2.56 V internal.
583 //ADMUX |= ((1 << REFS0) ); // Vcc with external cap.
584 //ADMUX &= ~((1 << REFS1) | (1 << REFS0)); // 0,0 : aref.
585 ADMUX = aref | mux | ADLAR_BITS;
588 // ADCSRB |= (1 << ACME); // enable
589 // ADCSRB &= ~(1 << ADEN); // ?
592 //ADMUX = (ADMUX & ~MUXES); // start at 000 = ADC0
594 // clear adlar to left justify data
597 // set adlar to right justify data
598 //ADMUX |= (1 << ADLAR);
602 ADCSRA |= adate; // trigger enable
603 ADCSRB = en_mux | hispeed | trig | (ADCSRB & ~((1 << ADTS0) | (1 << ADTS1) | (1 << ADTS2))); // trigger select free running
605 // ADCSRA |= (1 << ADATE); // tiggger enable
607 ADCSRA |= (1 << ADEN); // ADC enable
608 ADCSRA |= (1 << ADSC); // start conversions q
613 void recovery(uint8_t on) {
614 DDRB |= (1 << RECOVERY_CONTROL);
616 PORTB &= ~(1 << RECOVERY_SINK); // SINK always zero
617 DDRB &= ~(1 << RECOVERY_SOURCE); // SOURCE high imp
620 DDRB |= (1 << RECOVERY_SINK); // SINK pull
623 PORTB |= (1 << RECOVERY_CONTROL);
625 PORTB |= (1 << RECOVERY_SOURCE); // SOURCE high
626 DDRB |= (1 << RECOVERY_SOURCE);
629 PORTB &= ~(1 << RECOVERY_CONTROL);
631 DDRB &= ~(1 << RECOVERY_SOURCE);
632 PORTB &= ~(1 << RECOVERY_SOURCE); // SOURCE low
633 DDRB &= ~(1 << RECOVERY_SINK); // SINK high-imp
635 //DDRB &= ~(1 << RECOVERY_SINK);
640 void strobe_w(uint8_t strobe_num) {
647 strobe_num = 15 - strobe_num;
650 printHex( strobe_num );
652 strobe_num = 9 - strobe_num;
653 printHex( strobe_num );
659 // XXX Kishsaver strobe (note that D0, D1 are not used)
660 case 2: PORTD |= (1 << 2); break;
661 case 3: PORTD |= (1 << 3); break;
662 case 4: PORTD |= (1 << 4); break;
663 case 5: PORTD |= (1 << 5); break;
666 case 6: PORTD |= (1 << 6); break;
667 case 7: PORTD |= (1 << 7); break;
668 case 8: PORTE |= (1 << 0); break;
669 case 9: PORTE |= (1 << 1); break;
670 case 15: PORTC |= (1 << 5); break;
674 case 6: PORTD |= (1 << 6); break;
675 case 7: PORTD |= (1 << 7); break;
677 case 8: PORTC |= (1 << 0); break;
678 case 9: PORTC |= (1 << 1); break;
679 case 10: PORTC |= (1 << 2); break;
680 case 11: PORTC |= (1 << 3); break;
681 case 12: PORTC |= (1 << 4); break;
682 case 13: PORTC |= (1 << 5); break;
683 case 14: PORTC |= (1 << 6); break;
684 case 15: PORTC |= (1 << 7); break;
686 case 16: PORTE |= (1 << 0); break;
687 case 17: PORTE |= (1 << 1); break;
692 case 6: PORTE |= (1 << 0); break;
693 case 7: PORTE |= (1 << 1); break;
695 case 8: PORTC |= (1 << 0); break;
696 case 9: PORTC |= (1 << 1); break;
697 case 10: PORTC |= (1 << 2); break;
698 case 11: PORTC |= (1 << 3); break;
699 case 12: PORTC |= (1 << 4); break;
700 case 13: PORTC |= (1 << 5); break;
701 case 14: PORTC |= (1 << 6); break;
702 case 15: PORTC |= (1 << 7); break;
707 case 6: PORTD |= (1 << 6); break;
708 case 7: PORTD |= (1 << 7); break;
710 case 8: PORTE |= (1 << 0); break;
711 case 9: PORTE |= (1 << 1); break;
713 case 10: PORTC |= (1 << 0); break;
714 case 11: PORTC |= (1 << 1); break;
715 case 12: PORTC |= (1 << 2); break;
716 case 13: PORTC |= (1 << 3); break;
717 case 14: PORTC |= (1 << 4); break;
718 case 15: PORTC |= (1 << 5); break;
720 case 16: PORTC |= (1 << 6); break;
721 case 17: PORTC |= (1 << 7); break;
735 int sampleColumn_i(uint8_t column, uint8_t muxes, int16_t * buffer) {
737 // ensure all probe lines are driven low, and chill for recovery delay.
742 _delay_us(RECOVERY_US);
747 for (uint8_t i=0; i<8; ++i) {
748 if(muxes & (1 << i)) {
753 SET_FULL_MUX(MUX_1_1); // crap sample will use this.
754 ADCSRA |= (1 << ADEN) | (1 << ADSC); // enable and start conversions
755 ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
759 while (! (ADCSRA & (1 << ADIF))); // wait until ready.
760 sample = ADC; // 1st sample, icky.
761 //ADC; // 1st sample, icky. XXX Not sure if the compiler throws this away, but less compiler warnings -HaaTa
767 * we are running in continuous mode, so we must setup the next
768 * read _before_ the current read completes.
787 ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
788 //wait for last read to complete.
789 while (! (ADCSRA & (1 << ADIF)));
790 sample = ADC; // throw away strobe'd value.
791 //ADC; // throw away strobe'd value.
794 for (uint8_t i=0; i <= index; ++i) {
797 SET_FULL_MUX(buffer[i]); // _next_ read will use this.
798 // wait for i-1'th read to complete:
799 ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
800 while (! (ADCSRA & (1 << ADIF)));
802 // retrieve last (i-1'th) read.
804 buffer[i-1] = ADC - OFFSET_VOLTAGE;
806 buffer[0] = ADC - OFFSET_VOLTAGE;
812 for (uint8_t i=0; i < index; ++i) {
815 SET_FULL_MUX(buffer[i]); // _next_ read will use this.
817 ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
818 while (! (ADCSRA & (1 << ADIF)));
819 sample = ADC; // throw away warmup value.
820 //ADC; // throw away warmup value.
825 ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
826 while (! (ADCSRA & (1 << ADIF)));
827 //sample = ADC; // throw away warmup value.
828 ADC; // throw away warmup value.
831 ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
832 while (! (ADCSRA & (1 << ADIF)));
834 // retrieve current read.
835 buffer[i] = ADC - OFFSET_VOLTAGE;
843 ADCSRA &= ~(1 << ADEN);
845 // pull all columns' probe-lines low.
850 // test for humps. :/
851 /*uint16_t delta = full_av;
852 if(buffer[0] > BUMP_THRESHOLD + delta) {
856 return 0; //all good.
864 int sampleColumn_k(uint8_t column, int16_t * buffer) {
865 // ensure all probe lines are driven low, and chill for recovery delay.
868 ADCSRA |= (1 << ADEN) | (1 << ADSC); // enable and start conversions
869 ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
871 // sync up with adc clock:
872 while (! (ADCSRA & (1 << ADIF))); // wait until ready.
873 //ADC; // throw it away. // XXX Not sure if the compiler throws this away, but less compiler warnings -HaaTa
874 sample = ADC; // throw it away.
876 for(uint8_t mux=0; mux < 8; ++mux) {
882 SET_FULL_MUX(mux); // our sample will use this
884 for(uint8_t i=0; i < 2; ++i) {
885 ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
886 //wait for last read to complete.
887 while (! (ADCSRA & (1 << ADIF)));
888 sample = ADC; // throw away strobe'd value.
889 //ADC; // throw away strobe'd value.
895 ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
896 //wait for last read to complete.
897 while (! (ADCSRA & (1 << ADIF)));
898 sample = ADC; // throw away strobe'd value.
899 //ADC; // throw away strobe'd value.
901 ADCSRA |= (1 << ADIF); // clear int flag by writing 1.
902 while (! (ADCSRA & (1 << ADIF)));
904 // retrieve current read.
905 buffer[mux] = ADC - OFFSET_VOLTAGE;
911 ADCSRA &= ~(1 << ADEN);
913 // pull all columns' probe-lines low.
924 int sampleColumn(uint8_t column) {
928 sampleColumn_i(column, 0x0f, samples+SAMPLE_OFFSET);
929 sampleColumn_i(column, 0xf0, samples+SAMPLE_OFFSET + 4 );
932 rval = sampleColumn_k(column, samples+SAMPLE_OFFSET);
934 //for(uint8_t i=0; i<1; ++i) { // TODO REMOVEME
935 for(uint8_t i=0; i<8; ++i) {
936 if(samples[SAMPLE_OFFSET + i] - adc_mux_averages[i] > BUMP_THRESHOLD) {
939 _delay_us(BUMP_REST_US);
942 error_data = samples[SAMPLE_OFFSET +i]; // | ((uint16_t)i << 8);
951 uint8_t testColumn(uint8_t strobe) {
954 for (uint8_t i=0; i < MUXES_COUNT; ++i) {
955 uint16_t delta = keys_averages[(strobe << MUXES_COUNT_XSHIFT) + i];
956 if ((int16_t)samples[SAMPLE_OFFSET + i] > threshold + delta) {
965 void dumpkeys(void) {
968 if (count >= WARMUP_LOOPS && error) {
974 for (uint8_t i=0; i < STROBE_LINES; ++i) {
975 printHex(usb_keymap[i]);
983 printHex(error_data);
989 // XXX Will be cleaned up eventually, but this will do for now :P -HaaTa
990 for (uint8_t i=0; i < STROBE_LINES; ++i) {
991 for(uint8_t j=0; j<MUXES_COUNT; ++j) {
992 if ( usb_keymap[i] & (1 << j) ) {
993 uint8_t key = (i << MUXES_COUNT_XSHIFT) + j;
995 // Add to the Macro processing buffer
996 // Automatically handles converting to a USB code and sending off to the PC
1009 //if(usb_dirty) print("\n");
1010 usb_keyboard_send();
1016 if(!dump_count) { // we don't want to debug-out during the measurements.
1018 // Averages currently set per key
1019 for(int i =0; i< KEY_COUNT; ++i) {
1022 } else if (!(i & 0x07)) {
1026 //printHex (keys_averages[(i >> MUXES_COUNT_XSHIFT) + (i & STROBE_LINES_MASK) ]);
1027 printHex (keys_averages[i]);
1032 // Previously read full ADC scans?
1033 for(int i =0; i< KEY_COUNT; ++i) {
1036 } else if (!(i & 0x07)) {
1040 //printHex (keys_averages[(i >> MUXES_COUNT_XSHIFT) + (i & STROBE_LINES_MASK) ]);
1041 //printHex (keys_averages_acc[i]);
1042 printHex(full_samples[i]);
1046 // Per strobe information
1047 // uint8_t cur_strober = 0xe;
1048 uint8_t cur_strober = ze_strober;
1051 printHex(cur_strober);
1054 // Previously read ADC scans on current strobe
1056 for (uint8_t i=0; i < MUXES_COUNT; ++i) {
1058 printHex(full_samples[(cur_strober << MUXES_COUNT_XSHIFT) + i]);
1061 // Averages current set on current strobe
1063 // printHex(threshold);
1064 for (uint8_t i=0; i < MUXES_COUNT; ++i) {
1066 printHex(keys_averages[(cur_strober << MUXES_COUNT_XSHIFT) + i]);
1071 for (uint8_t i=0; i< SAMPLES; ++i) {
1073 printHex(samples[i]);
1077 //dPrint((was_active)?" ":"*");
1079 //printHex(keymap[TEST_KEY_STROBE] & TEST_KEY_MASK);
1081 //printHex(keymap[TEST_KEY_STROBE]);
1086 //printHex(full_av);
1091 // Current keymap values
1092 for (uint8_t i=0; i < STROBE_LINES; ++i) {
1093 printHex(cur_keymap[i]);
1101 //printHex(adc_strobe_averages[ze_strober]);
1105 /* Already printing this above...
1106 for (uint8_t i=0; i < MUXES_COUNT; ++i) {
1108 //printHex(adc_mux_averages[i] + adc_strobe_averages[ze_strober] - full_av);
1109 //printHex((adc_mux_averages[i] + adc_strobe_averages[ze_strober]) >> 1);
1110 //printHex((adc_mux_averages[i] * 3 + adc_strobe_averages[ze_strober]) >> 2);
1111 //printHex(adc_mux_averages[i] + threshold);
1112 //printHex(gsamples[i + SAMPLE_OFFSET] - (adc_mux_averages[i] + threshold) + 0x100);
1113 //printHex(keys_averages[(ze_strober << MUXES_COUNT_XSHIFT) + i] + (uint8_t)threshold);
1114 printHex(keys_averages[(ze_strober << MUXES_COUNT_XSHIFT) + i]);
1118 /* Being printed in dumpkeys()
1123 printHex(error_data);
1139 //ze_strobe = (1 << (ze_strober ) );