/*
-Copyright 2012 Jun Wako
-Copyright 2014 Jack Humbert
+Copyright 2012-2018 Jun Wako, Jack Humbert, Yiancar
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
*/
#include <stdint.h>
#include <stdbool.h>
-#if defined(__AVR__)
-#include <avr/io.h>
-#endif
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h"
+#include "debounce.h"
+#include "quantum.h"
#if (MATRIX_COLS <= 8)
# define print_matrix_header() print("\nr/c 01234567\n")
# define ROW_SHIFTER ((uint32_t)1)
#endif
-#if (MATRIX_ROWS <= 8)
-# define COL_SHIFTER ((uint8_t)1)
-#elif (MATRIX_ROWS <= 16)
-# define COL_SHIFTER ((uint16_t)1)
-#elif (MATRIX_ROWS <= 32)
-# define COL_SHIFTER ((uint32_t)1)
-#endif
-
-
-
#ifdef MATRIX_MASKED
-extern const matrix_row_t matrix_mask[];
+ extern const matrix_row_t matrix_mask[];
#endif
-/* Set 0 if debouncing isn't needed */
-
-#ifndef DEBOUNCING_DELAY
-# define DEBOUNCING_DELAY 5
+#ifdef DIRECT_PINS
+static pin_t direct_pins[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS;
+#elif (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW)
+static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
+static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
#endif
-static uint8_t debouncing = DEBOUNCING_DELAY;
-
-static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
-static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
/* matrix state(1:on, 0:off) */
-static matrix_row_t matrix[MATRIX_ROWS];
-
-#if DIODE_DIRECTION == COL2ROW
- static matrix_row_t matrix_debouncing[MATRIX_ROWS];
-#else // ROW2COL
- static matrix_col_t matrix_transposed[MATRIX_COLS];
- static matrix_col_t matrix_transposed_debouncing[MATRIX_COLS];
-#endif
-
-#if (DIODE_DIRECTION == COL2ROW)
- static void init_cols(void);
- static matrix_row_t read_cols(void);
- static void unselect_rows(void);
- static void select_row(uint8_t row);
- static void unselect_row(uint8_t row);
-#else // ROW2COL
- static void init_rows(void);
- static matrix_col_t read_rows(void);
- static void unselect_cols(void);
- static void unselect_col(uint8_t col);
- static void select_col(uint8_t col);
-#endif
+static matrix_row_t raw_matrix[MATRIX_ROWS]; //raw values
+static matrix_row_t matrix[MATRIX_ROWS]; //debounced values
__attribute__ ((weak))
void matrix_init_quantum(void) {
return MATRIX_COLS;
}
-// void matrix_power_up(void) {
-// #if (DIODE_DIRECTION == COL2ROW)
-// for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
-// /* DDRxn */
-// _SFR_IO8((row_pins[r] >> 4) + 1) |= _BV(row_pins[r] & 0xF);
-// toggle_row(r);
-// }
-// for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
-// /* PORTxn */
-// _SFR_IO8((col_pins[c] >> 4) + 2) |= _BV(col_pins[c] & 0xF);
-// }
-// #else
-// for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
-// /* DDRxn */
-// _SFR_IO8((col_pins[c] >> 4) + 1) |= _BV(col_pins[c] & 0xF);
-// toggle_col(c);
-// }
-// for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
-// /* PORTxn */
-// _SFR_IO8((row_pins[r] >> 4) + 2) |= _BV(row_pins[r] & 0xF);
-// }
-// #endif
-// }
-
-void matrix_init(void) {
-
- // To use PORTF disable JTAG with writing JTD bit twice within four cycles.
- #if (defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) || defined(__AVR_ATmega32U4__))
- MCUCR |= _BV(JTD);
- MCUCR |= _BV(JTD);
- #endif
-
- // initialize row and col
-#if (DIODE_DIRECTION == COL2ROW)
- unselect_rows();
- init_cols();
-
- // initialize matrix state: all keys off
- for (uint8_t i=0; i < MATRIX_ROWS; i++) {
- matrix[i] = 0;
- matrix_debouncing[i] = 0;
- }
-
-#else // ROW2COL
- unselect_cols();
- init_rows();
-
- // initialize matrix state: all keys off
- for (uint8_t i=0; i < MATRIX_ROWS; i++) {
- matrix[i] = 0;
- }
-
- // initialize matrix state: all keys off
- for (uint8_t i=0; i < MATRIX_COLS; i++) {
- matrix_transposed_debouncing[i] = 0;
- }
-#endif
-
- matrix_init_quantum();
-}
-
-uint8_t matrix_scan(void)
-{
-
-#if (DIODE_DIRECTION == COL2ROW)
-
- // Set row, read cols
-
- for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
- select_row(i);
- wait_us(30); // without this wait read unstable value.
- matrix_row_t current_row = read_cols();
- if (matrix_debouncing[i] != current_row) {
- matrix_debouncing[i] = current_row;
- if (debouncing) {
- debug("bounce!: "); debug_hex(debouncing); debug("\n");
- }
- debouncing = DEBOUNCING_DELAY;
- }
- unselect_row(i);
- }
-
- if (debouncing) {
- if (--debouncing) {
- wait_ms(1);
- } else {
- for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
- matrix[i] = matrix_debouncing[i];
- }
- }
- }
-
-#else // ROW2COL
-
- // Set col, read rows
-
- for (uint8_t i = 0; i < MATRIX_COLS; i++) {
- select_col(i);
- wait_us(30); // without this wait read unstable value.
- matrix_col_t current_col = read_rows();
- if (matrix_transposed_debouncing[i] != current_col) {
- matrix_transposed_debouncing[i] = current_col;
- if (debouncing) {
- debug("bounce!: "); debug_hex(debouncing); debug("\n");
- }
- debouncing = DEBOUNCING_DELAY;
- }
- unselect_col(i);
- }
-
- if (debouncing) {
- if (--debouncing) {
- wait_ms(1);
- } else {
- for (uint8_t i = 0; i < MATRIX_COLS; i++) {
- matrix_transposed[i] = matrix_transposed_debouncing[i];
- }
- }
- }
-
- // Untranspose matrix
- 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_transposed[x] & (1<<y)) >> y) << x;
- }
- matrix[y] = row;
- }
-
-#endif
-
- matrix_scan_quantum();
-
- return 1;
-}
-
+//Deprecated.
bool matrix_is_modified(void)
{
- if (debouncing) return false;
+ if (debounce_active()) return false;
return true;
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
- return (matrix[row] & ((matrix_row_t)1<col));
+ return (matrix[row] & ((matrix_row_t)1<<col));
}
inline
}
+#ifdef DIRECT_PINS
-#if (DIODE_DIRECTION == COL2ROW)
-
-static void init_cols(void)
-{
- for(uint8_t x = 0; x < MATRIX_COLS; x++) {
- uint8_t pin = col_pins[x];
- _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
- _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
+static void init_pins(void) {
+ for (int row = 0; row < MATRIX_ROWS; row++) {
+ for (int col = 0; col < MATRIX_COLS; col++) {
+ pin_t pin = direct_pins[row][col];
+ if (pin != NO_PIN) {
+ setPinInputHigh(pin);
+ }
}
+ }
}
-static matrix_row_t read_cols(void)
-{
- matrix_row_t result = 0;
+static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
+ matrix_row_t last_row_value = current_matrix[current_row];
+ current_matrix[current_row] = 0;
- for(uint8_t x = 0; x < MATRIX_COLS; x++) {
- uint8_t pin = col_pins[x];
- result |= (_SFR_IO8(pin >> 4) & _BV(pin & 0xF)) ? 0 : (ROW_SHIFTER << x);
+ for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
+ pin_t pin = direct_pins[current_row][col_index];
+ if (pin != NO_PIN) {
+ current_matrix[current_row] |= readPin(pin) ? 0 : (ROW_SHIFTER << col_index);
}
+ }
- return result;
+ return (last_row_value != current_matrix[current_row]);
}
+#elif (DIODE_DIRECTION == COL2ROW)
+
static void select_row(uint8_t row)
{
- uint8_t pin = row_pins[row];
- _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
- _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
+ setPinOutput(row_pins[row]);
+ writePinLow(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
- uint8_t pin = row_pins[row];
- _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
- _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
+ setPinInputHigh(row_pins[row]);
}
static void unselect_rows(void)
{
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- uint8_t pin = row_pins[x];
- _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
- _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
+ setPinInputHigh(row_pins[x]);
}
}
-#else // ROW2COL
-
-static void init_rows(void)
-{
- for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- uint8_t pin = row_pins[x];
- _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
- _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
- }
+static void init_pins(void) {
+ unselect_rows();
+ for (uint8_t x = 0; x < MATRIX_COLS; x++) {
+ setPinInputHigh(col_pins[x]);
+ }
}
-static matrix_col_t read_rows(void)
+static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
{
- matrix_col_t result = 0;
+ // Store last value of row prior to reading
+ matrix_row_t last_row_value = current_matrix[current_row];
- for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- uint8_t pin = row_pins[x];
- result |= (_SFR_IO8(pin >> 4) & _BV(pin & 0xF)) ? 0 : (COL_SHIFTER << x);
+ // Clear data in matrix row
+ current_matrix[current_row] = 0;
+
+ // Select row and wait for row selecton to stabilize
+ select_row(current_row);
+ wait_us(30);
+
+ // For each col...
+ for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
+
+ // Select the col pin to read (active low)
+ uint8_t pin_state = readPin(col_pins[col_index]);
+
+ // Populate the matrix row with the state of the col pin
+ current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
}
- return result;
+ // Unselect row
+ unselect_row(current_row);
+
+ return (last_row_value != current_matrix[current_row]);
}
+#elif (DIODE_DIRECTION == ROW2COL)
+
static void select_col(uint8_t col)
{
- uint8_t pin = col_pins[col];
- _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
- _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
+ setPinOutput(col_pins[col]);
+ writePinLow(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
- uint8_t pin = col_pins[col];
- _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
- _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
+ setPinInputHigh(col_pins[col]);
}
static void unselect_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
- uint8_t pin = col_pins[x];
- _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
- _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
+ setPinInputHigh(col_pins[x]);
}
}
+static void init_pins(void) {
+ unselect_cols();
+ for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
+ setPinInputHigh(row_pins[x]);
+ }
+}
+
+static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
+{
+ bool matrix_changed = false;
+
+ // Select col and wait for col selecton to stabilize
+ select_col(current_col);
+ wait_us(30);
+
+ // For each row...
+ for(uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++)
+ {
+
+ // Store last value of row prior to reading
+ matrix_row_t last_row_value = current_matrix[row_index];
+
+ // Check row pin state
+ if (readPin(row_pins[row_index]) == 0)
+ {
+ // Pin LO, set col bit
+ current_matrix[row_index] |= (ROW_SHIFTER << current_col);
+ }
+ else
+ {
+ // Pin HI, clear col bit
+ current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
+ }
+
+ // Determine if the matrix changed state
+ if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
+ {
+ matrix_changed = true;
+ }
+ }
+
+ // Unselect col
+ unselect_col(current_col);
+
+ return matrix_changed;
+}
+
+#endif
+
+void matrix_init(void) {
+
+ // initialize key pins
+ init_pins();
+
+ // initialize matrix state: all keys off
+ for (uint8_t i=0; i < MATRIX_ROWS; i++) {
+ raw_matrix[i] = 0;
+ matrix[i] = 0;
+ }
+
+ debounce_init(MATRIX_ROWS);
+
+ matrix_init_quantum();
+}
+
+uint8_t matrix_scan(void)
+{
+ bool changed = false;
+
+#if defined(DIRECT_PINS) || (DIODE_DIRECTION == COL2ROW)
+ // Set row, read cols
+ for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) {
+ changed |= read_cols_on_row(raw_matrix, current_row);
+ }
+#elif (DIODE_DIRECTION == ROW2COL)
+ // Set col, read rows
+ for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
+ changed |= read_rows_on_col(raw_matrix, current_col);
+ }
#endif
+
+ debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
+
+ matrix_scan_quantum();
+ return (uint8_t)changed;
+}
projects / qmk_firmware.git / blobdiff