From eeb64437673c0f5c16f0ddf1e2a8362be81b615a Mon Sep 17 00:00:00 2001 From: Balz Guenat Date: Tue, 12 Dec 2017 03:05:12 +0100 Subject: actuation point adjustment for fc980c and fc660c (#2134) * add i2c lib submodule * add actuation point adjustment to fc980c * add actuation point adjustment to fc660c also. * use https for i2c submodule * move to existing i2c lib * properly remove old submodule * oops, forgot some files for the fc660c --- keyboards/fc660c/README.md | 11 +++ keyboards/fc660c/actuation_point.c | 87 ++++++++++++++++++++ keyboards/fc660c/actuation_point.h | 32 ++++++++ keyboards/fc660c/config.h | 9 +++ keyboards/fc660c/fc660c.c | 8 ++ keyboards/fc660c/i2c.c | 162 +++++++++++++++++++++++++++++++++++++ keyboards/fc660c/i2c.h | 49 +++++++++++ keyboards/fc660c/matrix.c | 2 +- keyboards/fc660c/rules.mk | 4 +- 9 files changed, 362 insertions(+), 2 deletions(-) create mode 100644 keyboards/fc660c/actuation_point.c create mode 100644 keyboards/fc660c/actuation_point.h create mode 100644 keyboards/fc660c/i2c.c create mode 100644 keyboards/fc660c/i2c.h (limited to 'keyboards/fc660c') diff --git a/keyboards/fc660c/README.md b/keyboards/fc660c/README.md index ce84abad8..5cb9bcea4 100644 --- a/keyboards/fc660c/README.md +++ b/keyboards/fc660c/README.md @@ -25,6 +25,17 @@ Thread on Geekhack: https://geekhack.org/index.php?topic=88439.0 Also: https://geekhack.org/index.php?topic=88720.0 + +Actuation Point adjustment +-------------------------- +You can adjust the actuation point of the keys by setting `ACTUATION_DEPTH_ADJUSTMENT` in `config.h`. +A value above 0 will result in a deeper, less sensitive actuation whereas a value above 1 will result in a more shallow, more sensitive actuation. +Be careful with this setting and use small values (+/-5). +See the `actuation-point-example` keymap of the `fc980c` keyboard for an example. +For more information, inspect the `fc660c_i2c` branch of TMK [here](https://github.com/tmk/tmk_keyboard/tree/fc660c_i2c). +Functionality for writing to the EEPROM has deliberately not been included to reduce the chance of people messing up their boards. + + Pinouts ------- diff --git a/keyboards/fc660c/actuation_point.c b/keyboards/fc660c/actuation_point.c new file mode 100644 index 000000000..5f4cb16f4 --- /dev/null +++ b/keyboards/fc660c/actuation_point.c @@ -0,0 +1,87 @@ +/* +Copyright 2017 Balz Guenat +based on work by Jun Wako + +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 . +*/ + +#include "actuation_point.h" +#include "i2c.h" + +/////////////////////////////////////////////////////////////////////////////// +// +// AD5258 I2C digital potentiometer +// http://www.analog.com/media/en/technical-documentation/data-sheets/AD5258.pdf +// +#define AD5258_ADDR 0b0011000 +#define AD5258_INST_RDAC 0x00 +#define AD5258_INST_EEPROM 0x20 + +uint8_t read_rdac(void) { + // read RDAC register + i2c_start_write(AD5258_ADDR); + i2c_master_write(AD5258_INST_RDAC); + i2c_start_read(AD5258_ADDR); + uint8_t ret = i2c_master_read(I2C_NACK); + i2c_master_stop(); + return ret; +}; + +uint8_t read_eeprom(void) { + i2c_start_write(AD5258_ADDR); + i2c_master_write(AD5258_INST_EEPROM); + i2c_start_read(AD5258_ADDR); + uint8_t ret = i2c_master_read(I2C_NACK); + i2c_master_stop(); + return ret; +}; + +void write_rdac(uint8_t rdac) { + // write RDAC register: + i2c_start_write(AD5258_ADDR); + i2c_master_write(AD5258_INST_RDAC); + i2c_master_write(rdac & 0x3F); + i2c_master_stop(); +}; + +void actuation_point_up(void) { + // write RDAC register: lower value makes actuation point shallow + uint8_t rdac = read_rdac(); + if (rdac == 0) + write_rdac(0); + else + write_rdac(rdac-1); +}; + +void actuation_point_down(void) { + // write RDAC register: higher value makes actuation point deep + uint8_t rdac = read_rdac(); + if (rdac == 63) + write_rdac(63); + else + write_rdac(rdac+1); +}; + +void adjust_actuation_point(int offset) { + i2c_master_init(); + uint8_t rdac = read_eeprom() + offset; + if (rdac > 63) { // protects from under and overflows + if (offset > 0) + write_rdac(63); + else + write_rdac(0); + } else { + write_rdac(rdac); + } +} diff --git a/keyboards/fc660c/actuation_point.h b/keyboards/fc660c/actuation_point.h new file mode 100644 index 000000000..f7066d92c --- /dev/null +++ b/keyboards/fc660c/actuation_point.h @@ -0,0 +1,32 @@ +/* +Copyright 2017 Balz Guenat + +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 . +*/ + +#ifndef ACTUATION_POINT_H +#define ACTUATION_POINT_H + +#include + +// see keymaps/actuation-point-example to see how these functions can be used. +uint8_t read_rdac(void); +uint8_t read_eeprom(void); +void actuation_point_up(void); +void actuation_point_down(void); + +// be careful with this. +void adjust_actuation_point(int offset); + +#endif diff --git a/keyboards/fc660c/config.h b/keyboards/fc660c/config.h index 0afd374a0..9771c8c03 100644 --- a/keyboards/fc660c/config.h +++ b/keyboards/fc660c/config.h @@ -64,6 +64,8 @@ along with this program. If not, see . * These options are also useful to firmware size reduction. */ +#define USE_I2C + /* disable debug print */ //#define NO_DEBUG @@ -77,4 +79,11 @@ along with this program. If not, see . //#define NO_ACTION_MACRO //#define NO_ACTION_FUNCTION +// higher value means deeper actuation point, less sensitive +// be careful and only make small adjustments (steps of 1 or 2). +// too high and keys will fail to actuate. too low and keys will actuate spontaneously. +// test all keys before further adjustment. +// this should probably stay in the range +/-5. +// #define ACTUATION_DEPTH_ADJUSTMENT 0 + #endif diff --git a/keyboards/fc660c/fc660c.c b/keyboards/fc660c/fc660c.c index f2a561767..da6ba9e74 100644 --- a/keyboards/fc660c/fc660c.c +++ b/keyboards/fc660c/fc660c.c @@ -16,10 +16,18 @@ along with this program. If not, see . */ #include "fc660c.h" +#ifdef ACTUATION_DEPTH_ADJUSTMENT +#include "actuation_point.h" +#endif + void matrix_init_kb(void) { // put your keyboard start-up code here // runs once when the firmware starts up +#ifdef ACTUATION_DEPTH_ADJUSTMENT + adjust_actuation_point(ACTUATION_DEPTH_ADJUSTMENT); +#endif + matrix_init_user(); } diff --git a/keyboards/fc660c/i2c.c b/keyboards/fc660c/i2c.c new file mode 100644 index 000000000..084c890c4 --- /dev/null +++ b/keyboards/fc660c/i2c.c @@ -0,0 +1,162 @@ +#include +#include +#include +#include +#include +#include +#include "i2c.h" + +#ifdef USE_I2C + +// Limits the amount of we wait for any one i2c transaction. +// Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is +// 9 bits, a single transaction will take around 90μs to complete. +// +// (F_CPU/SCL_CLOCK) => # of μC cycles to transfer a bit +// poll loop takes at least 8 clock cycles to execute +#define I2C_LOOP_TIMEOUT (9+1)*(F_CPU/SCL_CLOCK)/8 + +#define BUFFER_POS_INC() (slave_buffer_pos = (slave_buffer_pos+1)%SLAVE_BUFFER_SIZE) + +volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE]; + +static volatile uint8_t slave_buffer_pos; +static volatile bool slave_has_register_set = false; + +// Wait for an i2c operation to finish +inline static +void i2c_delay(void) { + uint16_t lim = 0; + while(!(TWCR & (1<10. + // Check datasheets for more info. + TWBR = ((F_CPU/SCL_CLOCK)-16)/2; +} + +// Start a transaction with the given i2c slave address. The direction of the +// transfer is set with I2C_READ and I2C_WRITE. +// returns: 0 => success +// 1 => error +uint8_t i2c_master_start(uint8_t address) { + TWCR = (1< slave ACK +// 1 => slave NACK +uint8_t i2c_master_write(uint8_t data) { + TWDR = data; + TWCR = (1<= SLAVE_BUFFER_SIZE ) { + ack = 0; + slave_buffer_pos = 0; + } + slave_has_register_set = true; + } else { + i2c_slave_buffer[slave_buffer_pos] = TWDR; + BUFFER_POS_INC(); + } + break; + + case TW_ST_SLA_ACK: + case TW_ST_DATA_ACK: + // master has addressed this device as a slave transmitter and is + // requesting data. + TWDR = i2c_slave_buffer[slave_buffer_pos]; + BUFFER_POS_INC(); + break; + + case TW_BUS_ERROR: // something went wrong, reset twi state + TWCR = 0; + default: + break; + } + // Reset everything, so we are ready for the next TWI interrupt + TWCR |= (1< + +#ifndef F_CPU +#define F_CPU 16000000UL +#endif + +#define I2C_READ 1 +#define I2C_WRITE 0 + +#define I2C_ACK 1 +#define I2C_NACK 0 + +#define SLAVE_BUFFER_SIZE 0x10 + +// i2c SCL clock frequency +#define SCL_CLOCK 400000L + +extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE]; + +void i2c_master_init(void); +uint8_t i2c_master_start(uint8_t address); +void i2c_master_stop(void); +uint8_t i2c_master_write(uint8_t data); +uint8_t i2c_master_read(int); +void i2c_reset_state(void); +void i2c_slave_init(uint8_t address); + + +static inline unsigned char i2c_start_read(unsigned char addr) { + return i2c_master_start((addr << 1) | I2C_READ); +} + +static inline unsigned char i2c_start_write(unsigned char addr) { + return i2c_master_start((addr << 1) | I2C_WRITE); +} + +// from SSD1306 scrips +extern unsigned char i2c_rep_start(unsigned char addr); +extern void i2c_start_wait(unsigned char addr); +extern unsigned char i2c_readAck(void); +extern unsigned char i2c_readNak(void); +extern unsigned char i2c_read(unsigned char ack); + +#define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak(); + +#endif diff --git a/keyboards/fc660c/matrix.c b/keyboards/fc660c/matrix.c index 211506fdf..69a96b979 100644 --- a/keyboards/fc660c/matrix.c +++ b/keyboards/fc660c/matrix.c @@ -21,7 +21,7 @@ along with this program. If not, see . */ #include #include -#include +#include "wait.h" #include "print.h" #include "debug.h" #include "util.h" diff --git a/keyboards/fc660c/rules.mk b/keyboards/fc660c/rules.mk index 883f7e657..c947947f8 100644 --- a/keyboards/fc660c/rules.mk +++ b/keyboards/fc660c/rules.mk @@ -61,4 +61,6 @@ NKRO_ENABLE ?= yes # USB Nkey Rollover - not yet supported in LUFA #EXTRALDFLAGS = -Wl,--relax CUSTOM_MATRIX = yes -SRC += matrix.c +SRC += matrix.c \ + actuation_point.c \ + i2c.c -- cgit v1.2.3-24-g4f1b