-/* Copyright (C) 2014 by Jacob Alexander
+/* Copyright (C) 2014-2015 by Jacob Alexander
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
// Project Includes
#include <cli.h>
+#include <kll_defs.h>
#include <led.h>
#include <print.h>
#include <macro.h>
+#include <Lib/delay.h>
// Local Includes
#include "matrix_scan.h"
+// ----- Defines -----
+
+#if ( DebounceThrottleDiv_define > 0 )
+nat_ptr_t Matrix_divCounter = 0;
+#endif
+
+
+
// ----- Function Declarations -----
// CLI Functions
// ----- Variables -----
// Scan Module command dictionary
-const char matrixCLIDictName[] = "Matrix Module Commands";
-const CLIDictItem matrixCLIDict[] = {
- { "matrixDebug", "Enables matrix debug mode, prints out each scan code." NL "\t\tIf argument \033[35mT\033[0m is given, prints out each scan code state transition.", cliFunc_matrixDebug },
- { "matrixState", "Prints out the current scan table N times." NL "\t\t \033[1mO\033[0m - Off, \033[1;33mP\033[0m - Press, \033[1;32mH\033[0m - Hold, \033[1;35mR\033[0m - Release, \033[1;31mI\033[0m - Invalid", cliFunc_matrixState },
+CLIDict_Entry( matrixDebug, "Enables matrix debug mode, prints out each scan code." NL "\t\tIf argument \033[35mT\033[0m is given, prints out each scan code state transition." );
+CLIDict_Entry( matrixState, "Prints out the current scan table N times." NL "\t\t \033[1mO\033[0m - Off, \033[1;33mP\033[0m - Press, \033[1;32mH\033[0m - Hold, \033[1;35mR\033[0m - Release, \033[1;31mI\033[0m - Invalid" );
+
+CLIDict_Def( matrixCLIDict, "Matrix Module Commands" ) = {
+ CLIDict_Item( matrixDebug ),
+ CLIDict_Item( matrixState ),
{ 0, 0, 0 } // Null entry for dictionary end
};
// Debounce Array
KeyState Matrix_scanArray[ Matrix_colsNum * Matrix_rowsNum ];
+// Ghost Arrays
+#ifdef GHOSTING_MATRIX
+KeyGhost Matrix_ghostArray[ Matrix_colsNum * Matrix_rowsNum ];
+
+uint8_t col_use[Matrix_colsNum], row_use[Matrix_rowsNum]; // used count
+uint8_t col_ghost[Matrix_colsNum], row_ghost[Matrix_rowsNum]; // marked as having ghost if 1
+#endif
+
+
// Matrix debug flag - If set to 1, for each keypress the scan code is displayed in hex
// If set to 2, for each key state change, the scan code is displayed along with the state
uint8_t matrixDebugMode = 0;
uint16_t matrixCurScans = 0;
uint16_t matrixPrevScans = 0;
+// System Timer used for delaying debounce decisions
+extern volatile uint32_t systick_millis_count;
+
// ----- Functions -----
// Assumes 0x40 between GPIO Port registers and 0x1000 between PORT pin registers
// See Lib/mk20dx.h
volatile unsigned int *GPIO_PDDR = (unsigned int*)(&GPIOA_PDDR) + gpio_offset;
+ #ifndef GHOSTING_MATRIX
volatile unsigned int *GPIO_PSOR = (unsigned int*)(&GPIOA_PSOR) + gpio_offset;
+ #endif
volatile unsigned int *GPIO_PCOR = (unsigned int*)(&GPIOA_PCOR) + gpio_offset;
volatile unsigned int *GPIO_PDIR = (unsigned int*)(&GPIOA_PDIR) + gpio_offset;
volatile unsigned int *PORT_PCR = (unsigned int*)(&PORTA_PCR0) + port_offset;
switch ( type )
{
case Type_StrobeOn:
+ #ifdef GHOSTING_MATRIX
+ *GPIO_PCOR |= (1 << gpio.pin);
+ *GPIO_PDDR |= (1 << gpio.pin); // output, low
+ #else
*GPIO_PSOR |= (1 << gpio.pin);
+ #endif
break;
case Type_StrobeOff:
+ #ifdef GHOSTING_MATRIX
+ // Ghosting martix needs to put not used (off) strobes in high impedance state
+ *GPIO_PDDR &= ~(1 << gpio.pin); // input, high Z state
+ #endif
*GPIO_PCOR |= (1 << gpio.pin);
break;
case Type_StrobeSetup:
+ #ifdef GHOSTING_MATRIX
+ *GPIO_PDDR &= ~(1 << gpio.pin); // input, high Z state
+ *GPIO_PCOR |= (1 << gpio.pin);
+ #else
// Set as output pin
*GPIO_PDDR |= (1 << gpio.pin);
+ #endif
// Configure pin with slow slew, high drive strength and GPIO mux
*PORT_PCR = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);
break;
case Type_Sense:
+ #ifdef GHOSTING_MATRIX // inverted
+ return *GPIO_PDIR & (1 << gpio.pin) ? 0 : 1;
+ #else
return *GPIO_PDIR & (1 << gpio.pin) ? 1 : 0;
+ #endif
case Type_SenseSetup:
// Set as input pin
print( NL );
info_msg("Max Keys: ");
printHex( Matrix_maxKeys );
+ print( NL );
// Clear out Debounce Array
for ( uint8_t item = 0; item < Matrix_maxKeys; item++ )
{
- Matrix_scanArray[ item ].prevState = KeyState_Off;
- Matrix_scanArray[ item ].curState = KeyState_Off;
- Matrix_scanArray[ item ].activeCount = 0;
- Matrix_scanArray[ item ].inactiveCount = 0xFFFF; // Start at 'off' steady state
+ Matrix_scanArray[ item ].prevState = KeyState_Off;
+ Matrix_scanArray[ item ].curState = KeyState_Off;
+ Matrix_scanArray[ item ].activeCount = 0;
+ Matrix_scanArray[ item ].inactiveCount = DebounceDivThreshold_define; // Start at 'off' steady state
+ Matrix_scanArray[ item ].prevDecisionTime = 0;
+ #ifdef GHOSTING_MATRIX
+ Matrix_ghostArray[ item ].prev = KeyState_Off;
+ Matrix_ghostArray[ item ].cur = KeyState_Off;
+ Matrix_ghostArray[ item ].saved = KeyState_Off;
+ #endif
}
// Clear scan stats counters
// NOTE: scanNum should be reset to 0 after a USB send (to reset all the counters)
void Matrix_scan( uint16_t scanNum )
{
+#if ( DebounceThrottleDiv_define > 0 )
+ // Scan-rate throttling
+ // By scanning using a divider, the scan rate slowed down
+ // DebounceThrottleDiv_define == 1 means -> /2 or half scan rate
+ // This helps with bouncy switches on fast uCs
+ if ( !( Matrix_divCounter++ & (1 << ( DebounceThrottleDiv_define - 1 )) ) )
+ return;
+#endif
+
// Increment stats counters
if ( scanNum > matrixMaxScans ) matrixMaxScans = scanNum;
if ( scanNum == 0 )
matrixCurScans++;
}
+ // Read systick for event scheduling
+ uint8_t currentTime = (uint8_t)systick_millis_count;
+
// For each strobe, scan each of the sense pins
for ( uint8_t strobe = 0; strobe < Matrix_colsNum; strobe++ )
{
+ #ifdef STROBE_DELAY
+ uint32_t start = micros();
+ while ((micros() - start) < STROBE_DELAY);
+ #endif
+
// Strobe Pin
Matrix_pin( Matrix_cols[ strobe ], Type_StrobeOn );
+ #ifdef STROBE_DELAY
+ start = micros();
+ while ((micros() - start) < STROBE_DELAY);
+ #endif
+
// Scan each of the sense pins
for ( uint8_t sense = 0; sense < Matrix_rowsNum; sense++ )
{
if ( Matrix_pin( Matrix_rows[ sense ], Type_Sense ) )
{
// Only update if not going to wrap around
- if ( state->activeCount < 0xFFFF ) state->activeCount += 1;
+ if ( state->activeCount < DebounceDivThreshold_define ) state->activeCount += 1;
state->inactiveCount >>= 1;
}
// Signal Not Detected
else
{
// Only update if not going to wrap around
- if ( state->inactiveCount < 0xFFFF ) state->inactiveCount += 1;
+ if ( state->inactiveCount < DebounceDivThreshold_define ) state->inactiveCount += 1;
state->activeCount >>= 1;
}
// Check for state change if it hasn't been set
+ // But only if enough time has passed since last state change
// Only check if the minimum number of scans has been met
// the current state is invalid
// and either active or inactive count is over the debounce threshold
if ( state->curState == KeyState_Invalid )
{
+ // Determine time since last decision
+ uint8_t lastTransition = currentTime - state->prevDecisionTime;
+
+ // Attempt state transition
switch ( state->prevState )
{
case KeyState_Press:
}
else
{
+ // If not enough time has passed since Hold
+ // Keep previous state
+ if ( lastTransition < MinDebounceTime_define )
+ {
+ //warn_print("FAST Release stopped");
+ state->curState = state->prevState;
+ continue;
+ }
+
state->curState = KeyState_Release;
}
break;
case KeyState_Off:
if ( state->activeCount > state->inactiveCount )
{
+ // If not enough time has passed since Hold
+ // Keep previous state
+ if ( lastTransition < MinDebounceTime_define )
+ {
+ //warn_print("FAST Press stopped");
+ state->curState = state->prevState;
+ continue;
+ }
+
state->curState = KeyState_Press;
}
else
break;
}
+ // Update decision time
+ state->prevDecisionTime = currentTime;
+
// Send keystate to macro module
+ #ifndef GHOSTING_MATRIX
Macro_keyState( key, state->curState );
+ #endif
// Matrix Debug, only if there is a state change
if ( matrixDebugMode && state->curState != state->prevState )
Matrix_pin( Matrix_cols[ strobe ], Type_StrobeOff );
}
+
+ // Matrix ghosting check and elimination
+ // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+#ifdef GHOSTING_MATRIX
+ // strobe = column, sense = row
+
+ // Count (rows) use for columns
+ //print("C ");
+ for ( uint8_t col = 0; col < Matrix_colsNum; col++ )
+ {
+ uint8_t used = 0;
+ for ( uint8_t row = 0; row < Matrix_rowsNum; row++ )
+ {
+ uint8_t key = Matrix_colsNum * row + col;
+ KeyState *state = &Matrix_scanArray[ key ];
+ if ( keyOn(state->curState) )
+ used++;
+ }
+ //printInt8(used);
+ col_use[col] = used;
+ col_ghost[col] = 0; // clear
+ }
+
+ // Count (columns) use for rows
+ //print(" R ");
+ for ( uint8_t row = 0; row < Matrix_rowsNum; row++ )
+ {
+ uint8_t used = 0;
+ for ( uint8_t col = 0; col < Matrix_colsNum; col++ )
+ {
+ uint8_t key = Matrix_colsNum * row + col;
+ KeyState *state = &Matrix_scanArray[ key ];
+ if ( keyOn(state->curState) )
+ used++;
+ }
+ //printInt8(used);
+ row_use[row] = used;
+ row_ghost[row] = 0; // clear
+ }
+
+ // Check if matrix has ghost
+ // Happens when key is pressed and some other key is pressed in same row and another in same column
+ //print(" G ");
+ for ( uint8_t col = 0; col < Matrix_colsNum; col++ )
+ {
+ for ( uint8_t row = 0; row < Matrix_rowsNum; row++ )
+ {
+ uint8_t key = Matrix_colsNum * row + col;
+ KeyState *state = &Matrix_scanArray[ key ];
+ if ( keyOn(state->curState) && col_use[col] >= 2 && row_use[row] >= 2 )
+ {
+ // mark col and row as having ghost
+ col_ghost[col] = 1;
+ row_ghost[row] = 1;
+ //print(" "); printInt8(col); print(","); printInt8(row);
+ }
+ }
+ }
+ //print( NL );
+
+ // Send keys
+ for ( uint8_t col = 0; col < Matrix_colsNum; col++ )
+ {
+ for ( uint8_t row = 0; row < Matrix_rowsNum; row++ )
+ {
+ uint8_t key = Matrix_colsNum * row + col;
+ KeyState *state = &Matrix_scanArray[ key ];
+ KeyGhost *st = &Matrix_ghostArray[ key ];
+
+ // col or row is ghosting (crossed)
+ uint8_t ghost = (col_ghost[col] > 0 || row_ghost[row] > 0) ? 1 : 0;
+
+ st->prev = st->cur; // previous
+ // save state if no ghost or outside ghosted area
+ if ( ghost == 0 )
+ st->saved = state->curState; // save state if no ghost
+ // final
+ // use saved state if ghosting, or current if not
+ st->cur = ghost > 0 ? st->saved : state->curState;
+
+ // Send keystate to macro module
+ KeyPosition k = !st->cur
+ ? (!st->prev ? KeyState_Off : KeyState_Release)
+ : ( st->prev ? KeyState_Hold : KeyState_Press);
+ Macro_keyState( key, k );
+ }
+ }
+#endif
+ // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+
// State Table Output Debug
if ( matrixDebugStateCounter > 0 )
{
if ( arg1Ptr[0] != '\0' )
{
- matrixDebugStateCounter = (uint16_t)decToInt( arg1Ptr );
+ matrixDebugStateCounter = (uint16_t)numToInt( arg1Ptr );
}
}
projects / kiibohd-controller.git / blobdiff