mirror of
https://github.com/qmk/qmk_firmware
synced 2024-11-14 07:55:28 +00:00
cbc5de67be
* Preliminary support for Duck Eagle/Viper V2 60% board. This is a copy of the octagon/v2 with things changed to reach a compiling state
* Get a 60% keymap compiling, this might not be what the eagle/viper
really supports
* Update readme to point to correct GeekHack link
* Get keymap working on a Duck Eagle
* Add code submitted by profanum429
- Add HHKB style top row to v2.h
- Modify read_rows function to take into accout the caps lock firmware key
- Modify default keymap to match the new v2.h
- Adjust readmes
* Fix bug related to col 0 not working
* Add keymap for mechmerlin
* Add profanum429's viper hhkb layout
* Add visual representation for mechmerlin layout
Add navigation keys to keymap
* Add a better visual representation to the mechmerlin keymap
* Add profanum429's Viper layout!
* Updated profanum429 keymap to match a full HHKB
Enabled media keys in rules.mk
* Revert "Updated profanum429 keymap to match a full HHKB"
This reverts commit ed914160d7.
* Fix default keymap for Eagle
* Enable extra keys for audio control support
* Modified timings in indicator_leds to accomodate the WS2811S chips on the Eagle/Viper2 PCBs at 800kHz with a 16mHz clock
Modified the backlight settings to not interfere with the default RGB underglow code from QMK
Modified the order of the LEDs in the LED status bar at the top of the Eagle/Viper2 PCBs (3,2,1,6,5,4,8,7 order)
* Cleaned up indicator code to remove unused functions as the RGB underglow uses the
default driver provided by QMK
Commented out backlighting code in v2.c
* update readmes to reflect profanum's awesome contributions and fix typo in make instructions
* Remove custom RGB logic and just rely on QMK RGB underglow. We'll leave the backlighting in place for now
266 lines
6.2 KiB
C
266 lines
6.2 KiB
C
/*
|
|
Copyright 2017 MechMerlin <mechmerlin@gmail.com>
|
|
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
|
|
the Free Software Foundation, either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <util/delay.h>
|
|
#include <avr/io.h>
|
|
#include <stdio.h>
|
|
#include "matrix.h"
|
|
#include "util.h"
|
|
#include "print.h"
|
|
#include "debug.h"
|
|
|
|
static uint8_t debouncing = DEBOUNCING_DELAY;
|
|
|
|
/* matrix state(1:on, 0:off) */
|
|
static matrix_row_t matrix[MATRIX_ROWS];
|
|
static matrix_row_t matrix_debouncing[MATRIX_ROWS];
|
|
|
|
static uint8_t read_rows(uint8_t col);
|
|
static void init_rows(void);
|
|
static void unselect_cols(void);
|
|
static void select_col(uint8_t col);
|
|
|
|
__attribute__ ((weak))
|
|
void matrix_init_quantum(void) {
|
|
matrix_init_kb();
|
|
}
|
|
|
|
__attribute__ ((weak))
|
|
void matrix_scan_quantum(void) {
|
|
matrix_scan_kb();
|
|
}
|
|
|
|
__attribute__ ((weak))
|
|
void matrix_init_kb(void) {
|
|
matrix_init_user();
|
|
}
|
|
|
|
__attribute__ ((weak))
|
|
void matrix_scan_kb(void) {
|
|
matrix_scan_user();
|
|
}
|
|
|
|
__attribute__ ((weak))
|
|
void matrix_init_user(void) {
|
|
}
|
|
|
|
__attribute__ ((weak))
|
|
void matrix_scan_user(void) {
|
|
}
|
|
|
|
void backlight_init_ports(void)
|
|
{
|
|
DDRD |= 0b11010000;
|
|
PORTD &= ~0b01010000;
|
|
PORTD |= 0b10000000;
|
|
DDRB |= 0b00011111;
|
|
PORTB &= ~0b00001110;
|
|
PORTB |= 0b00010001;
|
|
DDRE |= 0b01000000;
|
|
PORTE &= ~0b01000000;
|
|
}
|
|
|
|
void matrix_init(void) {
|
|
backlight_init_ports();
|
|
unselect_cols();
|
|
init_rows();
|
|
|
|
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
|
|
matrix[i] = 0;
|
|
matrix_debouncing[i] = 0;
|
|
}
|
|
|
|
matrix_init_quantum();
|
|
}
|
|
|
|
uint8_t matrix_scan(void) {
|
|
for (uint8_t col = 0; col < MATRIX_COLS; col++) {
|
|
select_col(col);
|
|
_delay_us(3);
|
|
|
|
uint8_t rows = read_rows(col);
|
|
|
|
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
|
|
bool prev_bit = matrix_debouncing[row] & ((matrix_row_t)1<<col);
|
|
bool curr_bit = rows & (1<<row);
|
|
if (prev_bit != curr_bit) {
|
|
matrix_debouncing[row] ^= ((matrix_row_t)1<<col);
|
|
debouncing = DEBOUNCING_DELAY;
|
|
}
|
|
}
|
|
unselect_cols();
|
|
}
|
|
|
|
if (debouncing) {
|
|
if (--debouncing) {
|
|
_delay_ms(1);
|
|
} else {
|
|
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
|
|
matrix[i] = matrix_debouncing[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
matrix_scan_quantum();
|
|
return 1;
|
|
}
|
|
|
|
inline matrix_row_t matrix_get_row(uint8_t row) {
|
|
return matrix[row];
|
|
}
|
|
|
|
void matrix_print(void) {
|
|
print("\nr/c 0123456789ABCDEF\n");
|
|
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
|
|
xprintf("%02X: %032lb\n", row, bitrev32(matrix_get_row(row)));
|
|
}
|
|
}
|
|
|
|
/* Row pin configuration
|
|
* row: 0 1 2 3 4 5
|
|
* pin: PB7 PD0 PD1 PD2 PD3 PD5
|
|
*
|
|
* Esc uses its own pin PE2
|
|
*/
|
|
static void init_rows(void) {
|
|
DDRD &= ~0b00101111;
|
|
PORTD &= ~0b00101111;
|
|
|
|
DDRB &= ~0b10000000;
|
|
PORTB &= ~0b10000000;
|
|
|
|
DDRE &= ~0b00000100;
|
|
PORTE |= 0b00000100;
|
|
}
|
|
|
|
static uint8_t read_rows(uint8_t col) {
|
|
|
|
return (PIND&(1<<0) ? (1<<0) : 0) |
|
|
(PIND&(1<<1) ? (1<<1) : 0) |
|
|
(PIND&(1<<2) ? (1<<2) : 0) |
|
|
(PIND&(1<<3) ? (1<<3) : 0) |
|
|
(PIND&(1<<5) ? (1<<4) : 0) |
|
|
(PINB&(1<<7) ? (1<<5) : 0) |
|
|
(col==0 ? ((PINE&(1<<2) ? 0 : (1<<2))) : 0);
|
|
|
|
}
|
|
|
|
uint8_t read_fwkey(void)
|
|
{
|
|
return PINE&(1<<2) ? 0 : (1<<2);
|
|
}
|
|
|
|
/* Columns 0 - 15
|
|
* These columns uses two 74HC237D 3 to 8 bit demultiplexers.
|
|
* col / pin: PC6 PB6 PF0 PF1 PC7
|
|
* 0: 1 0 0 0 0
|
|
* 1: 1 0 1 0 0
|
|
* 2: 1 0 0 1 0
|
|
* 3: 1 0 1 1 0
|
|
* 4: 1 0 0 0 1
|
|
* 5: 1 0 1 0 1
|
|
* 6: 1 0 0 1 1
|
|
* 7: 1 0 1 1 1
|
|
* 8: 0 1 0 0 0
|
|
* 9: 0 1 1 0 0
|
|
* 10: 0 1 0 1 0
|
|
* 11: 0 1 1 1 0
|
|
* 12: 0 1 0 0 1
|
|
* 13: 0 1 1 0 1
|
|
* 14: 0 1 0 1 1
|
|
* 15: 0 1 1 1 1
|
|
*
|
|
*/
|
|
static void unselect_cols(void) {
|
|
DDRB |= 0b01000000;
|
|
PORTB &= ~0b01000000;
|
|
|
|
DDRC |= 0b11000000;
|
|
PORTC &= ~0b11000000;
|
|
|
|
DDRF |= 0b00000011;
|
|
PORTF &= ~0b00000011;
|
|
}
|
|
|
|
static void select_col(uint8_t col) {
|
|
|
|
switch (col) {
|
|
case 0:
|
|
PORTC |= 0b01000000;
|
|
break;
|
|
case 1:
|
|
PORTC |= 0b01000000;
|
|
PORTF |= 0b00000001;
|
|
break;
|
|
case 2:
|
|
PORTC |= 0b01000000;
|
|
PORTF |= 0b00000010;
|
|
break;
|
|
case 3:
|
|
PORTC |= 0b01000000;
|
|
PORTF |= 0b00000011;
|
|
break;
|
|
case 4:
|
|
PORTC |= 0b11000000;
|
|
break;
|
|
case 5:
|
|
PORTC |= 0b11000000;
|
|
PORTF |= 0b00000001;
|
|
break;
|
|
case 6:
|
|
PORTC |= 0b11000000;
|
|
PORTF |= 0b00000010;
|
|
break;
|
|
case 7:
|
|
PORTC |= 0b11000000;
|
|
PORTF |= 0b00000011;
|
|
break;
|
|
case 8:
|
|
PORTB |= 0b01000000;
|
|
break;
|
|
case 9:
|
|
PORTB |= 0b01000000;
|
|
PORTF |= 0b00000001;
|
|
break;
|
|
case 10:
|
|
PORTB |= 0b01000000;
|
|
PORTF |= 0b00000010;
|
|
break;
|
|
case 11:
|
|
PORTB |= 0b01000000;
|
|
PORTF |= 0b00000011;
|
|
break;
|
|
case 12:
|
|
PORTB |= 0b01000000;
|
|
PORTC |= 0b10000000;
|
|
break;
|
|
case 13:
|
|
PORTB |= 0b01000000;
|
|
PORTF |= 0b00000001;
|
|
PORTC |= 0b10000000;
|
|
break;
|
|
case 14:
|
|
PORTB |= 0b01000000;
|
|
PORTF |= 0b00000010;
|
|
PORTC |= 0b10000000;
|
|
break;
|
|
case 15:
|
|
PORTB |= 0b01000000;
|
|
PORTF |= 0b00000011;
|
|
PORTC |= 0b10000000;
|
|
break;
|
|
}
|
|
}
|