@ -1,6 +1,6 @@
/*
/*
Copyright 2012 Jun Wako Copyright 2012 Jun Wako
Generated by planckkeyboard . com ( 2014 Jack Humbert ) Copyright 2014 Jack Humbert
This program is free software : you can redistribute it and / or modify 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 it under the terms of the GNU General Public License as published by
@ -15,300 +15,211 @@ GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program . If not , see < http : //www.gnu.org/licenses/>.
along with this program . If not , see < http : //www.gnu.org/licenses/>.
*/ */
/*
* scan matrix
*/
# include <stdint.h> # include <stdint.h>
# include <stdbool.h> # include <stdbool.h>
# include <avr/io.h> # include <avr/io.h>
# include <util/delay.h> # include "wait.h"
# include "print.h" # include "print.h"
# include "debug.h" # include "debug.h"
# include "util.h" # include "util.h"
# include "matrix.h" # include "matrix.h"
# if ndef DEBOUNCE # if def MATRIX_HAS_GHOST
# define DEBOUNCE 10 # error "The universal matrix.c file cannot be used for this keyboard."
# endif # endif
static uint8_t debouncing = DEBOUNCE ;
/* matrix state(1:on, 0:off) */ # ifndef DEBOUNCING_DELAY
static matrix_row_t matrix [ MATRIX_ROWS ] ; # define DEBOUNCING_DELAY 5
static matrix_row_t matrix_debouncing [ MATRIX_ROWS ] ;
# if DIODE_DIRECTION == ROW2COL
static matrix_row_t matrix_reversed [ MATRIX_COLS ] ;
static matrix_row_t matrix_reversed_debouncing [ MATRIX_COLS ] ;
# endif # endif
static const io_pin_t row_pins [ MATRIX_ROWS ] = MATRIX_ROW_PINS ;
# if MATRIX_COLS > 16 static const io_pin_t col_pins [ MATRIX_COLS ] = MATRIX_COL_PINS ;
# define SHIFTER 1UL
/* matrix state */
# if DIODE_DIRECTION == COL2ROW
static matrix_row_t matrix [ MATRIX_ROWS ] ;
static matrix_row_t debouncing_matrix [ MATRIX_ROWS ] ;
# else # else
# define SHIFTER 1
static matrix_col_t matrix [ MATRIX_COLS ] ;
static matrix_col_t debouncing_matrix [ MATRIX_COLS ] ;
# endif # endif
static int8_t debouncing_delay = - 1 ;
# if DIODE_DIRECTION == COL2ROW
static void toggle_row ( uint8_t row ) ;
static matrix_row_t read_cols ( void ) ; static matrix_row_t read_cols ( void ) ;
static void init_cols ( void ) ; # else
static void unselect_rows ( void ) ; static void toggle_col ( uint8_t col ) ;
static void select_row ( uint8_t row ) ; static matrix_col_t read_rows ( void ) ;
# endif
__attribute__ ( ( weak ) ) __attribute__ ( ( weak ) )
void matrix_init_quantum ( void ) { void matrix_init_quantum ( void ) {
} }
__attribute__ ( ( weak ) ) __attribute__ ( ( weak ) )
void matrix_scan_quantum ( void ) { void matrix_scan_quantum ( void ) {
} }
inline uint8_t matrix_rows ( void ) {
uint8_t matrix_rows ( void )
{
return MATRIX_ROWS ;
return MATRIX_ROWS ;
} }
inline uint8_t matrix_cols ( void ) {
uint8_t matrix_cols ( void )
{
return MATRIX_COLS ;
return MATRIX_COLS ;
} }
void matrix_init ( void ) void matrix_init ( void ) {
{ /* frees PORTF by setting the JTD bit twice within four cycles */
// To use PORTF disable JTAG with writing JTD bit twice within four cycles.
MCUCR | = _BV ( JTD ) ;
MCUCR | = ( 1 < < JTD ) ;
MCUCR | = _BV ( JTD ) ;
MCUCR | = ( 1 < < JTD ) ;
/* initializes the I/O pins */
# if DIODE_DIRECTION == COL2ROW
for ( int8_t r = MATRIX_ROWS - 1 ; r > = 0 ; - - r ) {
// initialize row and col
/* DDRxn */
unselect_rows ( ) ;
_SFR_IO8 ( row_pins [ r ] . input_addr + 1 ) | = _BV ( row_pins [ r ] . bit ) ;
init_cols ( ) ;
toggle_row ( r ) ;
// initialize matrix state: all keys off
for ( uint8_t i = 0 ; i < MATRIX_ROWS ; i + + ) {
matrix [ i ] = 0 ;
matrix_debouncing [ i ] = 0 ;
}
}
for ( int8_t c = MATRIX_COLS - 1 ; c > = 0 ; - - c ) {
/* PORTxn */
_SFR_IO8 ( col_pins [ c ] . input_addr + 2 ) | = _BV ( col_pins [ c ] . bit ) ;
}
# else
for ( int8_t c = MATRIX_COLS - 1 ; c > = 0 ; - - c ) {
/* DDRxn */
_SFR_IO8 ( col_pins [ c ] . input_addr + 1 ) | = _BV ( col_pins [ c ] . bit ) ;
toggle_col ( c ) ;
}
for ( int8_t r = MATRIX_ROWS - 1 ; r > = 0 ; - - r ) {
/* PORTxn */
_SFR_IO8 ( row_pins [ r ] . input_addr + 2 ) | = _BV ( row_pins [ r ] . bit ) ;
}
# endif
matrix_init_quantum ( ) ;
matrix_init_quantum ( ) ;
} }
uint8_t matrix_scan ( void )
{
# if DIODE_DIRECTION == COL2ROW # if DIODE_DIRECTION == COL2ROW
for ( uint8_t i = 0 ; i < MATRIX_ROWS ; i + + ) {
uint8_t matrix_scan ( void ) {
select_row ( i ) ;
for ( int8_t r = MATRIX_ROWS - 1 ; r > = 0 ; - - r ) {
_delay_us ( 30 ) ; // without this wait read unstable value.
toggle_row ( r ) ;
matrix_row_t cols = read_cols ( ) ;
matrix_row_t state = read_cols ( ) ;
if ( matrix_debouncing [ i ] ! = cols ) {
if ( debouncing_matrix [ r ] ! = state ) {
matrix_debouncing [ i ] = cols ;
debouncing_matrix [ r ] = state ;
if ( debouncing ) {
debouncing_delay = DEBOUNCING_DELAY ;
debug ( " bounce!: " ) ; debug_hex ( debouncing ) ; debug ( " \n " ) ;
}
debouncing = DEBOUNCE ;
}
}
unselect_rows( ) ;
toggle_row ( r ) ;
}
}
if ( debouncing_delay > = 0 ) {
if ( debouncing ) {
dprintf ( " Debouncing delay remaining: %X \n " , debouncing_delay ) ;
if ( - - debouncing ) {
- - debouncing_delay ;
_delay_ms ( 1 ) ;
if ( debouncing_delay > = 0 ) {
} else {
wait_ms ( 1 ) ;
for ( uint8_t i = 0 ; i < MATRIX_ROWS ; i + + ) {
matrix [ i ] = matrix_debouncing [ i ] ;
}
}
}
}
else {
# else for ( int8_t r = MATRIX_ROWS - 1 ; r > = 0 ; - - r ) {
for ( uint8_t i = 0 ; i < MATRIX_COLS ; i + + ) {
matrix [ r ] = debouncing_matrix [ r ] ;
select_row ( i ) ;
_delay_us ( 30 ) ; // without this wait read unstable value.
matrix_row_t rows = read_cols ( ) ;
if ( matrix_reversed_debouncing [ i ] ! = rows ) {
matrix_reversed_debouncing [ i ] = rows ;
if ( debouncing ) {
debug ( " bounce!: " ) ; debug_hex ( debouncing ) ; debug ( " \n " ) ;
}
}
debouncing = DEBOUNCE ;
}
}
unselect_rows ( ) ;
}
}
if ( debouncing ) {
if ( - - debouncing ) {
_delay_ms ( 1 ) ;
} else {
for ( uint8_t i = 0 ; i < MATRIX_COLS ; i + + ) {
matrix_reversed [ i ] = matrix_reversed_debouncing [ i ] ;
}
}
}
for ( uint8_t y = 0 ; y < MATRIX_ROWS ; y + + ) {
matrix_row_t row = 0 ;
for ( uint8_t x = 0 ; x < MATRIX_COLS ; x + + ) {
row | = ( ( matrix_reversed [ x ] & ( 1 < < y ) ) > > y ) < < x ;
}
matrix [ y ] = row ;
}
# endif
matrix_scan_quantum ( ) ;
matrix_scan_quantum ( ) ;
return 1 ;
return 1 ;
} }
bool matrix_is_modified ( void ) static void toggle_row ( uint8_t row ) {
{ /* PINxn */
if ( debouncing ) return false ;
_SFR_IO8 ( row_pins [ row ] . input_addr ) = _BV ( row_pins [ row ] . bit ) ;
return true ;
} }
inline static matrix_row_t read_cols ( void ) {
bool matrix_is_on ( uint8_t row , uint8_t col ) matrix_row_t state = 0 ;
{ for ( int8_t c = MATRIX_COLS - 1 ; c > = 0 ; - - c ) {
return ( matrix [ row ] & ( ( matrix_row_t ) 1 < col ) ) ;
/* PINxn */
if ( ! ( _SFR_IO8 ( col_pins [ c ] . input_addr ) & _BV ( col_pins [ c ] . bit ) ) ) {
state | = ( matrix_row_t ) 1 < < c ;
}
}
return state ;
} }
inline matrix_row_t matrix_get_row ( uint8_t row ) {
matrix_row_t matrix_get_row ( uint8_t row )
{
return matrix [ row ] ;
return matrix [ row ] ;
} }
void matrix_print ( void ) # else
{ uint8_t matrix_scan ( void ) {
print ( " \n r/c 0123456789ABCDEF \n " ) ;
for ( int8_t c = MATRIX_COLS - 1 ; c > = 0 ; - - c ) {
for ( uint8_t row = 0 ; row < MATRIX_ROWS ; row + + ) {
toggle_col ( c ) ;
phex ( row ) ; print ( " : " ) ;
matrix_col_t state = read_rows ( ) ;
pbin_reverse16 ( matrix_get_row ( row ) ) ;
if ( debouncing_matrix [ c ] ! = state ) {
print ( " \n " ) ;
debouncing_matrix [ c ] = state ;
debouncing_delay = DEBOUNCING_DELAY ;
}
toggle_col ( c ) ;
}
}
} if ( debouncing_delay > = 0 ) {
dprintf ( " Debouncing delay remaining: %X \n " , debouncing_delay ) ;
uint8_t matrix_key_count ( void ) - - debouncing_delay ;
{ if ( debouncing_delay > = 0 ) {
uint8_t count = 0 ;
wait_ms ( 1 ) ;
for ( uint8_t i = 0 ; i < MATRIX_ROWS ; i + + ) {
}
count + = bitpop16 ( matrix [ i ] ) ;
else {
for ( int8_t c = MATRIX_COLS - 1 ; c > = 0 ; - - c ) {
matrix [ c ] = debouncing_matrix [ c ] ;
}
}
}
}
return count ;
matrix_scan_quantum ( ) ;
return 1 ;
} }
static void init_cols ( void ) static void toggle_col ( uint8_t col ) {
{ /* PINxn */
int B = 0 , C = 0 , D = 0 , E = 0 , F = 0 ;
_SFR_IO8 ( col_pins [ col ] . input_addr ) = _BV ( col_pins [ col ] . bit ) ;
}
# if DIODE_DIRECTION == COL2ROW static matrix_col_t read_rows ( void ) {
for ( int x = 0 ; x < MATRIX_COLS ; x + + ) {
matrix_col_t state = 0 ;
int col = COLS [ x ] ;
for ( int8_t r = MATRIX_ROWS - 1 ; r > = 0 ; - - r ) {
# else /* PINxn */
for ( int x = 0 ; x < MATRIX_ROWS ; x + + ) {
if ( ! ( _SFR_IO8 ( row_pins [ r ] . input_addr ) & _BV ( row_pins [ r ] . bit ) ) ) {
int col = ROWS [ x ] ;
state | = ( matrix_col_t ) 1 < < r ;
# endif
if ( ( col & 0xF0 ) = = 0x20 ) {
B | = ( 1 < < ( col & 0x0F ) ) ;
} else if ( ( col & 0xF0 ) = = 0x30 ) {
C | = ( 1 < < ( col & 0x0F ) ) ;
} else if ( ( col & 0xF0 ) = = 0x40 ) {
D | = ( 1 < < ( col & 0x0F ) ) ;
} else if ( ( col & 0xF0 ) = = 0x50 ) {
E | = ( 1 < < ( col & 0x0F ) ) ;
} else if ( ( col & 0xF0 ) = = 0x60 ) {
F | = ( 1 < < ( col & 0x0F ) ) ;
}
}
}
}
DDRB & = ~ ( B ) ; PORTB | = ( B ) ;
return state ;
DDRC & = ~ ( C ) ; PORTC | = ( C ) ;
DDRD & = ~ ( D ) ; PORTD | = ( D ) ;
DDRE & = ~ ( E ) ; PORTE | = ( E ) ;
DDRF & = ~ ( F ) ; PORTF | = ( F ) ;
} }
static matrix_row_t read_cols ( void ) matrix_row_t matrix_get_row ( uint8_t row ) {
{ matrix_row_t state = 0 ;
matrix_row_t result = 0 ;
matrix_col_t mask = ( matrix_col_t ) 1 < < row ;
for ( int8_t c = MATRIX_COLS - 1 ; c > = 0 ; - - c ) {
# if DIODE_DIRECTION == COL2ROW if ( matrix [ c ] & mask ) {
for ( int x = 0 ; x < MATRIX_COLS ; x + + ) {
state | = ( matrix_row_t ) 1 < < c ;
int col = COLS [ x ] ;
# else
for ( int x = 0 ; x < MATRIX_ROWS ; x + + ) {
int col = ROWS [ x ] ;
# endif
if ( ( col & 0xF0 ) = = 0x20 ) {
result | = ( PINB & ( 1 < < ( col & 0x0F ) ) ? 0 : ( SHIFTER < < x ) ) ;
} else if ( ( col & 0xF0 ) = = 0x30 ) {
result | = ( PINC & ( 1 < < ( col & 0x0F ) ) ? 0 : ( SHIFTER < < x ) ) ;
} else if ( ( col & 0xF0 ) = = 0x40 ) {
result | = ( PIND & ( 1 < < ( col & 0x0F ) ) ? 0 : ( SHIFTER < < x ) ) ;
} else if ( ( col & 0xF0 ) = = 0x50 ) {
result | = ( PINE & ( 1 < < ( col & 0x0F ) ) ? 0 : ( SHIFTER < < x ) ) ;
} else if ( ( col & 0xF0 ) = = 0x60 ) {
result | = ( PINF & ( 1 < < ( col & 0x0F ) ) ? 0 : ( SHIFTER < < x ) ) ;
}
}
}
}
return result ;
return state ;
} }
static void unselect_rows ( void )
{
int B = 0 , C = 0 , D = 0 , E = 0 , F = 0 ;
# if DIODE_DIRECTION == COL2ROW
for ( int x = 0 ; x < MATRIX_ROWS ; x + + ) {
int row = ROWS [ x ] ;
# else
for ( int x = 0 ; x < MATRIX_COLS ; x + + ) {
int row = COLS [ x ] ;
# endif # endif
if ( ( row & 0xF0 ) = = 0x20 ) {
B | = ( 1 < < ( row & 0x0F ) ) ;
bool matrix_is_modified ( void ) {
} else if ( ( row & 0xF0 ) = = 0x30 ) {
if ( debouncing_delay > = 0 ) return false ;
C | = ( 1 < < ( row & 0x0F ) ) ;
return true ;
} else if ( ( row & 0xF0 ) = = 0x40 ) {
D | = ( 1 < < ( row & 0x0F ) ) ;
} else if ( ( row & 0xF0 ) = = 0x50 ) {
E | = ( 1 < < ( row & 0x0F ) ) ;
} else if ( ( row & 0xF0 ) = = 0x60 ) {
F | = ( 1 < < ( row & 0x0F ) ) ;
}
}
DDRB & = ~ ( B ) ; PORTB | = ( B ) ;
DDRC & = ~ ( C ) ; PORTC | = ( C ) ;
DDRD & = ~ ( D ) ; PORTD | = ( D ) ;
DDRE & = ~ ( E ) ; PORTE | = ( E ) ;
DDRF & = ~ ( F ) ; PORTF | = ( F ) ;
} }
static void select_row ( uint8_t row ) bool matrix_is_on ( uint8_t row , uint8_t col ) {
{ return matrix_get_row ( row ) & ( matrix_row_t ) 1 < < col ;
}
# if DIODE_DIRECTION == COL2ROW void matrix_print ( void ) {
int row_pin = ROWS [ row ] ;
dprintln ( " Human-readable matrix state: " ) ;
# else for ( uint8_t r = 0 ; r < MATRIX_ROWS ; r + + ) {
int row_pin = COLS [ row ] ;
dprintf ( " State of row %X: %016b \n " , r , bitrev16 ( matrix_get_row ( r ) ) ) ;
# endif }
}
if ( ( row_pin & 0xF0 ) = = 0x20 ) {
uint8_t matrix_key_count ( void ) {
DDRB | = ( 1 < < ( row_pin & 0x0F ) ) ;
uint8_t count = 0 ;
PORTB & = ~ ( 1 < < ( row_pin & 0x0F ) ) ;
for ( int8_t r = MATRIX_ROWS - 1 ; r > = 0 ; - - r ) {
} else if ( ( row_pin & 0xF0 ) = = 0x30 ) {
count + = bitpop16 ( matrix_get_row ( r ) ) ;
DDRC | = ( 1 < < ( row_pin & 0x0F ) ) ;
PORTC & = ~ ( 1 < < ( row_pin & 0x0F ) ) ;
} else if ( ( row_pin & 0xF0 ) = = 0x40 ) {
DDRD | = ( 1 < < ( row_pin & 0x0F ) ) ;
PORTD & = ~ ( 1 < < ( row_pin & 0x0F ) ) ;
} else if ( ( row_pin & 0xF0 ) = = 0x50 ) {
DDRE | = ( 1 < < ( row_pin & 0x0F ) ) ;
PORTE & = ~ ( 1 < < ( row_pin & 0x0F ) ) ;
} else if ( ( row_pin & 0xF0 ) = = 0x60 ) {
DDRF | = ( 1 < < ( row_pin & 0x0F ) ) ;
PORTF & = ~ ( 1 < < ( row_pin & 0x0F ) ) ;
}
}
return count ;
} }
Eric Tang
9 years ago
committed by
Jack Humbert