Takeshi ISHII
2 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 165 additions and 913 deletions
Split View
Diff Options
-
+2 -8keyboards/helix/pico/config.h
-
+15 -20keyboards/helix/pico/keymaps/biacco/keymap.c
-
+2 -4keyboards/helix/pico/keymaps/biacco/rules.mk
-
+15 -120keyboards/helix/pico/keymaps/default/keymap.c
-
+2 -4keyboards/helix/pico/keymaps/default/readme.md
-
+2 -12keyboards/helix/pico/keymaps/default/readme_jp.md
-
+2 -4keyboards/helix/pico/keymaps/default/rules.mk
-
+15 -148keyboards/helix/pico/keymaps/mtei/keymap.c
-
+2 -4keyboards/helix/pico/keymaps/mtei/rules.mk
-
+0 -342keyboards/helix/pico/matrix.c
-
+42 -0keyboards/helix/pico/override_helix_options.mk-maintenance
-
+15 -14keyboards/helix/pico/pico.c
-
+15 -5keyboards/helix/pico/pico.h
-
+34 -104keyboards/helix/pico/post_rules.mk
-
+0 -2keyboards/helix/pico/qmk_conf/rules.mk
-
+2 -2keyboards/helix/pico/rules.mk
-
+0 -104keyboards/helix/pico/split_util.c
-
+0 -16keyboards/helix/pico/split_util.h
+ 2
- 8
keyboards/helix/pico/config.h
View File
+ 15
- 20
keyboards/helix/pico/keymaps/biacco/keymap.c
View File
+ 2
- 4
keyboards/helix/pico/keymaps/biacco/rules.mk
View File
+ 15
- 120
keyboards/helix/pico/keymaps/default/keymap.c
View File
+ 2
- 4
keyboards/helix/pico/keymaps/default/readme.md
View File
+ 2
- 12
keyboards/helix/pico/keymaps/default/readme_jp.md
View File
+ 2
- 4
keyboards/helix/pico/keymaps/default/rules.mk
View File
+ 15
- 148
keyboards/helix/pico/keymaps/mtei/keymap.c
View File
+ 2
- 4
keyboards/helix/pico/keymaps/mtei/rules.mk
View File
+ 0
- 342
keyboards/helix/pico/matrix.c
View File
| @ -1,342 +0,0 @@ | |||
| /* | |||
| Copyright 2012 Jun Wako <wakojun@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/>. | |||
| */ | |||
| /* | |||
| * scan matrix | |||
| */ | |||
| #include <stdint.h> | |||
| #include <stdbool.h> | |||
| #include <avr/io.h> | |||
| #include <avr/wdt.h> | |||
| #include <avr/interrupt.h> | |||
| #include <util/delay.h> | |||
| #include "print.h" | |||
| #include "debug.h" | |||
| #include "util.h" | |||
| #include "matrix.h" | |||
| #include "split_util.h" | |||
| #include "quantum.h" | |||
| #ifdef USE_MATRIX_I2C | |||
| # include "i2c.h" | |||
| #else // USE_SERIAL | |||
| # include "serial.h" | |||
| #endif | |||
| #ifndef DEBOUNCE | |||
| # define DEBOUNCE 5 | |||
| #endif | |||
| #define ERROR_DISCONNECT_COUNT 5 | |||
| static uint8_t debouncing = DEBOUNCE; | |||
| static const int ROWS_PER_HAND = MATRIX_ROWS/2; | |||
| static uint8_t error_count = 0; | |||
| 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]; | |||
| static matrix_row_t matrix_debouncing[MATRIX_ROWS]; | |||
| static matrix_row_t read_cols(void); | |||
| static void init_cols(void); | |||
| static void unselect_rows(void); | |||
| static void select_row(uint8_t row); | |||
| static uint8_t matrix_master_scan(void); | |||
| __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) { | |||
| } | |||
| inline | |||
| uint8_t matrix_rows(void) | |||
| { | |||
| return MATRIX_ROWS; | |||
| } | |||
| inline | |||
| uint8_t matrix_cols(void) | |||
| { | |||
| return MATRIX_COLS; | |||
| } | |||
| void matrix_init(void) | |||
| { | |||
| split_keyboard_setup(); | |||
| // initialize row and col | |||
| unselect_rows(); | |||
| init_cols(); | |||
| setPinOutput(B0); | |||
| setPinOutput(D5); | |||
| writePinHigh(B0); | |||
| writePinHigh(D5); | |||
| // initialize matrix state: all keys off | |||
| for (uint8_t i=0; i < MATRIX_ROWS; i++) { | |||
| matrix[i] = 0; | |||
| matrix_debouncing[i] = 0; | |||
| } | |||
| matrix_init_quantum(); | |||
| } | |||
| uint8_t _matrix_scan(void) | |||
| { | |||
| // Right hand is stored after the left in the matirx so, we need to offset it | |||
| int offset = isLeftHand ? 0 : (ROWS_PER_HAND); | |||
| for (uint8_t i = 0; i < ROWS_PER_HAND; i++) { | |||
| select_row(i); | |||
| _delay_us(30); // without this wait read unstable value. | |||
| matrix_row_t cols = read_cols(); | |||
| if (matrix_debouncing[i+offset] != cols) { | |||
| matrix_debouncing[i+offset] = cols; | |||
| debouncing = DEBOUNCE; | |||
| } | |||
| unselect_rows(); | |||
| } | |||
| if (debouncing) { | |||
| if (--debouncing) { | |||
| _delay_ms(1); | |||
| } else { | |||
| for (uint8_t i = 0; i < ROWS_PER_HAND; i++) { | |||
| matrix[i+offset] = matrix_debouncing[i+offset]; | |||
| } | |||
| } | |||
| } | |||
| return 1; | |||
| } | |||
| #ifdef USE_MATRIX_I2C | |||
| // Get rows from other half over i2c | |||
| int i2c_transaction(void) { | |||
| int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; | |||
| int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE); | |||
| if (err) goto i2c_error; | |||
| // start of matrix stored at 0x00 | |||
| err = i2c_master_write(0x00); | |||
| if (err) goto i2c_error; | |||
| // Start read | |||
| err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ); | |||
| if (err) goto i2c_error; | |||
| if (!err) { | |||
| int i; | |||
| for (i = 0; i < ROWS_PER_HAND-1; ++i) { | |||
| matrix[slaveOffset+i] = i2c_master_read(I2C_ACK); | |||
| } | |||
| matrix[slaveOffset+i] = i2c_master_read(I2C_NACK); | |||
| i2c_master_stop(); | |||
| } else { | |||
| i2c_error: // the cable is disconnceted, or something else went wrong | |||
| i2c_reset_state(); | |||
| return err; | |||
| } | |||
| return 0; | |||
| } | |||
| #else // USE_SERIAL | |||
| int serial_transaction(void) { | |||
| int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; | |||
| int ret=serial_update_buffers(); | |||
| if (ret ) { | |||
| if(ret==2) writePinLow(B0); | |||
| return 1; | |||
| } | |||
| writePinHigh(B0); | |||
| for (int i = 0; i < ROWS_PER_HAND; ++i) { | |||
| matrix[slaveOffset+i] = serial_slave_buffer[i]; | |||
| } | |||
| return 0; | |||
| } | |||
| #endif | |||
| uint8_t matrix_scan(void) | |||
| { | |||
| if (is_helix_master()) { | |||
| matrix_master_scan(); | |||
| }else{ | |||
| matrix_slave_scan(); | |||
| int offset = (isLeftHand) ? ROWS_PER_HAND : 0; | |||
| for (int i = 0; i < ROWS_PER_HAND; ++i) { | |||
| matrix[offset+i] = serial_master_buffer[i]; | |||
| } | |||
| matrix_scan_quantum(); | |||
| } | |||
| return 1; | |||
| } | |||
| uint8_t matrix_master_scan(void) { | |||
| int ret = _matrix_scan(); | |||
| #ifndef KEYBOARD_helix_rev1 | |||
| int offset = (isLeftHand) ? 0 : ROWS_PER_HAND; | |||
| #ifdef USE_MATRIX_I2C | |||
| // for (int i = 0; i < ROWS_PER_HAND; ++i) { | |||
| /* i2c_slave_buffer[i] = matrix[offset+i]; */ | |||
| // i2c_slave_buffer[i] = matrix[offset+i]; | |||
| // } | |||
| #else // USE_SERIAL | |||
| for (int i = 0; i < ROWS_PER_HAND; ++i) { | |||
| serial_master_buffer[i] = matrix[offset+i]; | |||
| } | |||
| #endif | |||
| #endif | |||
| #ifdef USE_MATRIX_I2C | |||
| if( i2c_transaction() ) { | |||
| #else // USE_SERIAL | |||
| if( serial_transaction() ) { | |||
| #endif | |||
| // turn on the indicator led when halves are disconnected | |||
| writePinLow(D5); | |||
| error_count++; | |||
| if (error_count > ERROR_DISCONNECT_COUNT) { | |||
| // reset other half if disconnected | |||
| int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; | |||
| for (int i = 0; i < ROWS_PER_HAND; ++i) { | |||
| matrix[slaveOffset+i] = 0; | |||
| } | |||
| } | |||
| } else { | |||
| // turn off the indicator led on no error | |||
| writePinHigh(D5); | |||
| error_count = 0; | |||
| } | |||
| matrix_scan_quantum(); | |||
| return ret; | |||
| } | |||
| void matrix_slave_scan(void) { | |||
| _matrix_scan(); | |||
| int offset = (isLeftHand) ? 0 : ROWS_PER_HAND; | |||
| #ifdef USE_MATRIX_I2C | |||
| for (int i = 0; i < ROWS_PER_HAND; ++i) { | |||
| /* i2c_slave_buffer[i] = matrix[offset+i]; */ | |||
| i2c_slave_buffer[i] = matrix[offset+i]; | |||
| } | |||
| #else // USE_SERIAL | |||
| for (int i = 0; i < ROWS_PER_HAND; ++i) { | |||
| serial_slave_buffer[i] = matrix[offset+i]; | |||
| } | |||
| #endif | |||
| } | |||
| bool matrix_is_modified(void) | |||
| { | |||
| if (debouncing) return false; | |||
| return true; | |||
| } | |||
| inline | |||
| bool matrix_is_on(uint8_t row, uint8_t col) | |||
| { | |||
| return (matrix[row] & ((matrix_row_t)1<<col)); | |||
| } | |||
| 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++) { | |||
| print_hex8(row); print(": "); | |||
| print_bin_reverse16(matrix_get_row(row)); | |||
| print("\n"); | |||
| } | |||
| } | |||
| uint8_t matrix_key_count(void) | |||
| { | |||
| uint8_t count = 0; | |||
| for (uint8_t i = 0; i < MATRIX_ROWS; i++) { | |||
| count += bitpop16(matrix[i]); | |||
| } | |||
| return count; | |||
| } | |||
| static void init_cols(void) | |||
| { | |||
| for(int x = 0; x < MATRIX_COLS; x++) { | |||
| _SFR_IO8((col_pins[x] >> 4) + 1) &= ~_BV(col_pins[x] & 0xF); | |||
| _SFR_IO8((col_pins[x] >> 4) + 2) |= _BV(col_pins[x] & 0xF); | |||
| } | |||
| } | |||
| static matrix_row_t read_cols(void) | |||
| { | |||
| matrix_row_t result = 0; | |||
| for(int x = 0; x < MATRIX_COLS; x++) { | |||
| result |= (_SFR_IO8(col_pins[x] >> 4) & _BV(col_pins[x] & 0xF)) ? 0 : (1 << x); | |||
| } | |||
| return result; | |||
| } | |||
| static void unselect_rows(void) | |||
| { | |||
| for(int x = 0; x < ROWS_PER_HAND; x++) { | |||
| _SFR_IO8((row_pins[x] >> 4) + 1) &= ~_BV(row_pins[x] & 0xF); | |||
| _SFR_IO8((row_pins[x] >> 4) + 2) |= _BV(row_pins[x] & 0xF); | |||
| } | |||
| } | |||
| static void select_row(uint8_t row) | |||
| { | |||
| _SFR_IO8((row_pins[row] >> 4) + 1) |= _BV(row_pins[row] & 0xF); | |||
| _SFR_IO8((row_pins[row] >> 4) + 2) &= ~_BV(row_pins[row] & 0xF); | |||
| } | |||
+ 42
- 0
keyboards/helix/pico/override_helix_options.mk-maintenance
View File
| @ -0,0 +1,42 @@ | |||
| # | |||
| # This file is not normally used. It is used for maintenance testing purposes. | |||
| # To use it, do the following: | |||
| # | |||
| # $ cp override_helix_options.mk-maintenance override_helix_options.mk | |||
| # | |||
| $(info -------------------------) | |||
| $(info override_helix_options.mk) | |||
| $(info -------------------------) | |||
| define HELIX_OVERRIDE_PARSE | |||
| ifeq ($(strip $1),back) | |||
| LED_BACK_ENABLE = yes | |||
| LED_UNDERGLOW_ENABLE = no | |||
| endif | |||
| ifeq ($(strip $1),under) | |||
| LED_BACK_ENABLE = no | |||
| LED_UNDERGLOW_ENABLE = yes | |||
| endif | |||
| ifneq ($(filter noled led-off led_off,$(strip $1)),) | |||
| LED_BACK_ENABLE = no | |||
| LED_UNDERGLOW_ENABLE = no | |||
| endif | |||
| ifneq ($(filter noaudio audio-off audio_off,$(strip $1)),) | |||
| AUDIO_ENABLE = no | |||
| endif | |||
| ifneq ($(filter audio audio-on audio_on,$(strip $1)),) | |||
| AUDIO_ENABLE = yes | |||
| endif | |||
| ifneq ($(filter sc split-common split_common,$(strip $1)),) | |||
| SPLIT_KEYBOARD = yes | |||
| endif | |||
| ifneq ($(filter nosc no-sc no-split-common no-split_common,$(strip $1)),) | |||
| SPLIT_KEYBOARD = no | |||
| endif | |||
| ifeq ($(strip $1),scan) | |||
| DEBUG_MATRIX_SCAN_RATE_ENABLE = yes | |||
| endif | |||
| ifeq ($(strip $1),scan-api) | |||
| DEBUG_MATRIX_SCAN_RATE_ENABLE = api | |||
| endif | |||
| endef # end of HELIX_OVERRIDE_PARSE | |||
+ 15
- 14
keyboards/helix/pico/pico.c
View File
+ 15
- 5
keyboards/helix/pico/pico.h
View File
+ 34
- 104
keyboards/helix/pico/post_rules.mk
View File
+ 0
- 2
keyboards/helix/pico/qmk_conf/rules.mk
View File
| @ -1,4 +1,2 @@ | |||
| EXTRAKEY_ENABLE = yes # Audio control and System control | |||
| AUDIO_ENABLE = yes # Audio output | |||
| include $(strip $(KEYBOARD_LOCAL_FEATURES_MK)) | |||
+ 2
- 2
keyboards/helix/pico/rules.mk
View File
| @ -1,6 +1,6 @@ | |||
| SPLIT_KEYBOARD = yes | |||
| # Helix Spacific Build Options default values | |||
| OLED_ENABLE = no # OLED_ENABLE | |||
| LOCAL_GLCDFONT = no # use each keymaps "helixfont.h" insted of "common/glcdfont.c" | |||
| LED_BACK_ENABLE = no # LED backlight (Enable WS2812 RGB underlight.) | |||
| LED_UNDERGLOW_ENABLE = no # LED underglow (Enable WS2812 RGB underlight.) | |||
| LED_ANIMATIONS = yes # LED animations | |||
+ 0
- 104
keyboards/helix/pico/split_util.c
View File
| @ -1,104 +0,0 @@ | |||
| #include <avr/io.h> | |||
| #include <avr/wdt.h> | |||
| #include <avr/power.h> | |||
| #include <avr/interrupt.h> | |||
| #include <util/delay.h> | |||
| #include <avr/eeprom.h> | |||
| #include "split_util.h" | |||
| #include "matrix.h" | |||
| #include "keyboard.h" | |||
| #include "wait.h" | |||
| #ifdef USE_MATRIX_I2C | |||
| # include "i2c.h" | |||
| #else | |||
| # include "serial.h" | |||
| #endif | |||
| #ifdef EE_HANDS | |||
| # include "eeconfig.h" | |||
| #endif | |||
| #ifndef SPLIT_USB_TIMEOUT | |||
| #define SPLIT_USB_TIMEOUT 2500 | |||
| #endif | |||
| volatile bool isLeftHand = true; | |||
| bool waitForUsb(void) { | |||
| for (uint8_t i = 0; i < (SPLIT_USB_TIMEOUT / 100); i++) { | |||
| // This will return true of a USB connection has been established | |||
| if (UDADDR & _BV(ADDEN)) { | |||
| return true; | |||
| } | |||
| wait_ms(100); | |||
| } | |||
| // Avoid NO_USB_STARTUP_CHECK - Disable USB as the previous checks seem to enable it somehow | |||
| (USBCON &= ~(_BV(USBE) | _BV(OTGPADE))); | |||
| return false; | |||
| } | |||
| bool is_keyboard_left(void) { | |||
| #if defined(SPLIT_HAND_PIN) | |||
| // Test pin SPLIT_HAND_PIN for High/Low, if low it's right hand | |||
| setPinInput(SPLIT_HAND_PIN); | |||
| return readPin(SPLIT_HAND_PIN); | |||
| #elif defined(EE_HANDS) | |||
| return eeconfig_read_handedness(); | |||
| #elif defined(MASTER_RIGHT) | |||
| return !is_helix_master(); | |||
| #endif | |||
| return is_helix_master(); | |||
| } | |||
| bool is_helix_master(void) { | |||
| static enum { UNKNOWN, MASTER, SLAVE } usbstate = UNKNOWN; | |||
| // only check once, as this is called often | |||
| if (usbstate == UNKNOWN) { | |||
| #if defined(SPLIT_USB_DETECT) | |||
| usbstate = waitForUsb() ? MASTER : SLAVE; | |||
| #elif defined(__AVR__) | |||
| USBCON |= (1 << OTGPADE); // enables VBUS pad | |||
| wait_us(5); | |||
| usbstate = (USBSTA & (1 << VBUS)) ? MASTER : SLAVE; // checks state of VBUS | |||
| #else | |||
| usbstate = MASTER; | |||
| #endif | |||
| } | |||
| return (usbstate == MASTER); | |||
| } | |||
| static void keyboard_master_setup(void) { | |||
| #ifdef USE_MATRIX_I2C | |||
| i2c_master_init(); | |||
| #else | |||
| serial_master_init(); | |||
| #endif | |||
| } | |||
| static void keyboard_slave_setup(void) { | |||
| #ifdef USE_MATRIX_I2C | |||
| i2c_slave_init(SLAVE_I2C_ADDRESS); | |||
| #else | |||
| serial_slave_init(); | |||
| #endif | |||
| } | |||
| void split_keyboard_setup(void) { | |||
| isLeftHand = is_keyboard_left(); | |||
| if (is_helix_master()) { | |||
| keyboard_master_setup(); | |||
| } else { | |||
| keyboard_slave_setup(); | |||
| } | |||
| sei(); | |||
| } | |||
+ 0
- 16
keyboards/helix/pico/split_util.h
View File
| @ -1,16 +0,0 @@ | |||
| #pragma once | |||
| #include <stdbool.h> | |||
| #include "eeconfig.h" | |||
| #define SLAVE_I2C_ADDRESS 0x32 | |||
| extern volatile bool isLeftHand; | |||
| // slave version of matix scan, defined in matrix.c | |||
| void matrix_slave_scan(void); | |||
| void split_keyboard_setup(void); | |||
| bool is_helix_master(void); | |||
| void matrix_master_OLED_init (void); | |||