mirror of
https://github.com/openstenoproject/qmk
synced 2024-11-10 18:49:08 +00:00
03b8ce206d
* Keyboard: add Keyboardio Model01
This port implements key scanning and everything in their default
keymap.
It doesn't implement mouse warping; QMK can't do that (yet).
LED control is mostly not implemented. The ability to set all LEDs is
included because they can get stuck on coming from the bootloader
otherwise. Single LED control is also implemented for numpad indication.
The scanners also support batch LED transfer which is what you'd need if
you wanted to do fast effects. Gamma correction is also not implemented,
but is present in the original firmware. The necessary info for further
implementation is in the KeyboardioScanner module for Kaleidoscope.
To install on your keyboard:
make model01:avrdude
When prompted, hold the "prog" key on the keyboard to put it into
programming mode. This can also be achieved by holding the "prog" key
while plugging in the keyboard. This works even if the firmware is
corrupt or missing.
Hot plugging the halves seems to work fine, but there is no explicit
support for eg. making sure the matrix scan rate is reconfigured.
* model01: clean up includes and include guards
Uses #pragma once everywhere.
* model01: split LED and matrix code
This makes space if someone wants to implement better LED support
later on, the keyboard is a lot more capable than the current code.
* model01: separate I2C timeouts for matrix vs. LED
If the scanners have no data they don't ACK reads and just time out.
So we want a pretty short timeout to keep scan rates high.
Meanwhile the LED transfers might take longer - I don't know though,
so here we are conservative.
* model01: implement better LED control
- gamma correction from the manufacturer's firmware
- suitable delays to allow back to back LED writes
- this is fast enough to write the whole keyboard without noticeable
delay, in my experience
- minor bug fix: RHS Fn key was not addressable
* model01: add license to wire-protocol-constants.h
* model01: replace gamma LUT
The original was of unclear license origin. This one is functionally
identical and includes a generator should people wish to adjust it.
* model01: use the already-present CIE1931 lightness curve
...rather than baking in another gamma curve.
It's said that CIE1931 is the right thing to be using rather than gamma.
OK. Let it be so.
* model01: call matrix_init_user() from matrix_init_kb()
* model01: remove inapplicable config options from rules.mk
* model01: readme.md: update build environment links
94 lines
2.4 KiB
C
94 lines
2.4 KiB
C
/* Copyright 2018 James Laird-Wah
|
|
*
|
|
* 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 <quantum.h>
|
|
#include <i2c_master.h>
|
|
#include <string.h>
|
|
#include "model01.h"
|
|
|
|
/* If no key events have occurred, the scanners will time out on reads.
|
|
* So we don't want to be too permissive here. */
|
|
#define I2C_TIMEOUT 10
|
|
|
|
static matrix_row_t rows[MATRIX_ROWS];
|
|
#define ROWS_PER_HAND (MATRIX_ROWS / 2)
|
|
|
|
inline
|
|
uint8_t matrix_rows(void) {
|
|
return MATRIX_ROWS;
|
|
}
|
|
|
|
inline
|
|
uint8_t matrix_cols(void) {
|
|
return MATRIX_COLS;
|
|
}
|
|
|
|
static int i2c_read_hand(int hand) {
|
|
uint8_t buf[5];
|
|
i2c_status_t ret = i2c_receive(I2C_ADDR(hand), buf, sizeof(buf), I2C_TIMEOUT);
|
|
if (ret != I2C_STATUS_SUCCESS)
|
|
return 1;
|
|
|
|
if (buf[0] != TWI_REPLY_KEYDATA)
|
|
return 2;
|
|
|
|
int start_row = hand ? ROWS_PER_HAND : 0;
|
|
uint8_t *out = &rows[start_row];
|
|
memcpy(out, &buf[1], 4);
|
|
return 0;
|
|
}
|
|
|
|
static int i2c_set_keyscan_interval(int hand, int delay) {
|
|
uint8_t buf[] = {TWI_CMD_KEYSCAN_INTERVAL, delay};
|
|
i2c_status_t ret = i2c_transmit(I2C_ADDR(hand), buf, sizeof(buf), I2C_TIMEOUT);
|
|
return ret;
|
|
}
|
|
|
|
void matrix_init(void) {
|
|
/* Ensure scanner power is on - else right hand will not work */
|
|
DDRC |= _BV(7);
|
|
PORTC |= _BV(7);
|
|
|
|
i2c_init();
|
|
i2c_set_keyscan_interval(LEFT, 2);
|
|
i2c_set_keyscan_interval(RIGHT, 2);
|
|
memset(rows, 0, sizeof(rows));
|
|
|
|
matrix_init_quantum();
|
|
}
|
|
|
|
uint8_t matrix_scan(void) {
|
|
uint8_t ret = 0;
|
|
ret |= i2c_read_hand(LEFT);
|
|
ret |= i2c_read_hand(RIGHT);
|
|
matrix_scan_quantum();
|
|
return ret;
|
|
}
|
|
|
|
inline
|
|
matrix_row_t matrix_get_row(uint8_t row) {
|
|
return rows[row];
|
|
}
|
|
|
|
void matrix_print(void) {
|
|
print("\nr/c 0123456789ABCDEF\n");
|
|
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
|
|
phex(row); print(": ");
|
|
pbin_reverse16(matrix_get_row(row));
|
|
print("\n");
|
|
}
|
|
}
|
|
|
|
/* vim: set ts=2 sw=2 et: */
|