Comet46 add support for OLED (#4745)

* Add OLED support for Comet46

* fix length of char "name" of keylogger.c

* update ssd1306

* fix rules.mk

* update led-receiver keymap

* Update OLED related code

* add mod_state_reader & modify led_state_reader

* Update OLED related files

* Update kemaps

* Update readme

* change default-oled-display to default

* Add OSM compatibility to mod_state_reader

* Code formatting

* Use PROGMEM to store code_to_name

* Clean up satt keymap

* Rename default-led keymap to defult-rgbled
This commit is contained in:
satt99 2018-12-31 01:34:06 +09:00 committed by Drashna Jaelre
parent c2390bf321
commit 46b4b4407f
24 changed files with 1918 additions and 342 deletions

View File

@ -4,19 +4,11 @@ void uart_init(void) {
SERIAL_UART_INIT();
}
void led_init(void) {
DDRD |= (1<<1);
PORTD |= (1<<1);
DDRF |= (1<<4) | (1<<5);
PORTF |= (1<<4) | (1<<5);
}
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
matrix_init_user();
uart_init();
led_init();
}
void matrix_scan_kb(void) {

View File

@ -6,46 +6,6 @@
#include "backlight.h"
#include <stddef.h>
#define red_led_off PORTF |= (1<<5)
#define red_led_on PORTF &= ~(1<<5)
#define blu_led_off PORTF |= (1<<4)
#define blu_led_on PORTF &= ~(1<<4)
#define grn_led_off PORTD |= (1<<1)
#define grn_led_on PORTD &= ~(1<<1)
#define set_led_off red_led_off; grn_led_off; blu_led_off
#define set_led_red red_led_on; grn_led_off; blu_led_off
#define set_led_blue red_led_off; grn_led_off; blu_led_on
#define set_led_green red_led_off; grn_led_on; blu_led_off
#define set_led_yellow red_led_on; grn_led_on; blu_led_off
#define set_led_magenta red_led_on; grn_led_off; blu_led_on
#define set_led_cyan red_led_off; grn_led_on; blu_led_on
#define set_led_white red_led_on; grn_led_on; blu_led_on
/*
#define LED_B 5
#define LED_R 6
#define LED_G 7
#define all_leds_off PORTF &= ~(1<<LED_B) & ~(1<<LED_R) & ~(1<<LED_G)
#define red_led_on PORTF |= (1<<LED_R)
#define red_led_off PORTF &= ~(1<<LED_R)
#define grn_led_on PORTF |= (1<<LED_G)
#define grn_led_off PORTF &= ~(1<<LED_G)
#define blu_led_on PORTF |= (1<<LED_B)
#define blu_led_off PORTF &= ~(1<<LED_B)
#define set_led_off PORTF &= ~(1<<LED_B) & ~(1<<LED_R) & ~(1<<LED_G)
#define set_led_red PORTF = PORTF & ~(1<<LED_B) & ~(1<<LED_G) | (1<<LED_R)
#define set_led_blue PORTF = PORTF & ~(1<<LED_G) & ~(1<<LED_R) | (1<<LED_B)
#define set_led_green PORTF = PORTF & ~(1<<LED_B) & ~(1<<LED_R) | (1<<LED_G)
#define set_led_yellow PORTF = PORTF & ~(1<<LED_B) | (1<<LED_R) | (1<<LED_G)
#define set_led_magenta PORTF = PORTF & ~(1<<LED_G) | (1<<LED_R) | (1<<LED_B)
#define set_led_cyan PORTF = PORTF & ~(1<<LED_R) | (1<<LED_B) | (1<<LED_G)
#define set_led_white PORTF |= (1<<LED_B) | (1<<LED_R) | (1<<LED_G)
*/
// This a shortcut to help you visually see your layout.
// The first section contains all of the arguements
// The second converts the arguments into a two-dimensional array

View File

@ -41,12 +41,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define ONESHOT_TIMEOUT 500
/* key combination for command */
#define IS_COMMAND() ( \
keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
)
/*
* Feature disable options
* These options are also useful to firmware size reduction.
@ -65,6 +59,12 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
//#define NO_ACTION_MACRO
//#define NO_ACTION_FUNCTION
// Define masks for modifiers
#define MODS_SHIFT_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
#define MODS_CTRL_MASK (MOD_BIT(KC_LCTL)|MOD_BIT(KC_RCTRL))
#define MODS_ALT_MASK (MOD_BIT(KC_LALT)|MOD_BIT(KC_RALT))
#define MODS_GUI_MASK (MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
//UART settings for communication with the RF microcontroller
#define SERIAL_UART_BAUD 1000000
#define SERIAL_UART_DATA UDR1

162
keyboards/comet46/i2c.c Normal file
View File

@ -0,0 +1,162 @@
#include <util/twi.h>
#include <avr/io.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#include <util/twi.h>
#include <stdbool.h>
#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<<TWINT)) && lim < I2C_LOOP_TIMEOUT)
lim++;
// easier way, but will wait slightly longer
// _delay_us(100);
}
// Setup twi to run at 100kHz or 400kHz (see ./i2c.h SCL_CLOCK)
void i2c_master_init(void) {
// no prescaler
TWSR = 0;
// Set TWI clock frequency to SCL_CLOCK. Need TWBR>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<<TWINT) | (1<<TWEN) | (1<<TWSTA);
i2c_delay();
// check that we started successfully
if ( (TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START))
return 1;
TWDR = address;
TWCR = (1<<TWINT) | (1<<TWEN);
i2c_delay();
if ( (TW_STATUS != TW_MT_SLA_ACK) && (TW_STATUS != TW_MR_SLA_ACK) )
return 1; // slave did not acknowledge
else
return 0; // success
}
// Finish the i2c transaction.
void i2c_master_stop(void) {
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
uint16_t lim = 0;
while(!(TWCR & (1<<TWSTO)) && lim < I2C_LOOP_TIMEOUT)
lim++;
}
// Write one byte to the i2c slave.
// returns 0 => slave ACK
// 1 => slave NACK
uint8_t i2c_master_write(uint8_t data) {
TWDR = data;
TWCR = (1<<TWINT) | (1<<TWEN);
i2c_delay();
// check if the slave acknowledged us
return (TW_STATUS == TW_MT_DATA_ACK) ? 0 : 1;
}
// Read one byte from the i2c slave. If ack=1 the slave is acknowledged,
// if ack=0 the acknowledge bit is not set.
// returns: byte read from i2c device
uint8_t i2c_master_read(int ack) {
TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA);
i2c_delay();
return TWDR;
}
void i2c_reset_state(void) {
TWCR = 0;
}
void i2c_slave_init(uint8_t address) {
TWAR = address << 0; // slave i2c address
// TWEN - twi enable
// TWEA - enable address acknowledgement
// TWINT - twi interrupt flag
// TWIE - enable the twi interrupt
TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN);
}
ISR(TWI_vect);
ISR(TWI_vect) {
uint8_t ack = 1;
switch(TW_STATUS) {
case TW_SR_SLA_ACK:
// this device has been addressed as a slave receiver
slave_has_register_set = false;
break;
case TW_SR_DATA_ACK:
// this device has received data as a slave receiver
// The first byte that we receive in this transaction sets the location
// of the read/write location of the slaves memory that it exposes over
// i2c. After that, bytes will be written at slave_buffer_pos, incrementing
// slave_buffer_pos after each write.
if(!slave_has_register_set) {
slave_buffer_pos = TWDR;
// don't acknowledge the master if this memory loctaion is out of bounds
if ( slave_buffer_pos >= 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<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN);
}
#endif

49
keyboards/comet46/i2c.h Normal file
View File

@ -0,0 +1,49 @@
#ifndef I2C_H
#define I2C_H
#include <stdint.h>
#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 400kHz
#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

View File

@ -0,0 +1,226 @@
// this is the style you want to emulate.
// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
#include QMK_KEYBOARD_H
// Each layer gets a name for readability, which is then used in the keymap matrix below.
// The underscores don't mean anything - you can have a layer called STUFF or any other name.
// Layer names don't all need to be of the same length, obviously, and you can also skip them
// entirely and just use numbers.
enum comet46_layers
{
_QWERTY,
_COLEMAK,
_DVORAK,
_LOWER,
_RAISE,
_ADJUST,
};
enum custom_keycodes {
QWERTY = SAFE_RANGE,
COLEMAK,
DVORAK,
LOWER,
RAISE,
};
// Fillers to make layering more clear
#define _______ KC_TRNS
#define XXXXXXX KC_NO
#define LOWER MO(_LOWER)
#define RAISE MO(_RAISE)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Qwerty
* ,-----------------------------------------+ +-----------------------------------------.
* | Tab | Q | W | E | R | T | | Y | U | I | O | P | Bksp |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | Ctl | A | S | D | F | G | Esc | | Del | H | J | K | L | ; | " |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | { | | } | N | M | , | . | / | Shift|
* |------+------+------+------+------+------+------+ +------+------+------+------+------+-------------|
* | GUI | Lower| Space| | Enter| Raise| Alt |
* +--------------------/ \--------------------+
*/
[_QWERTY] = LAYOUT(
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_ESC, KC_DEL, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_LCBR, KC_RCBR, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT,
KC_LGUI, LOWER, KC_SPC, KC_ENT, RAISE, KC_LALT
),
/* Colemak
* ,-----------------------------------------+ +-----------------------------------------.
* | Tab | Q | W | F | P | G | | J | L | U | Y | ; | Bksp |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | Ctl | A | R | S | T | D | Esc | | Del | H | N | E | I | O | " |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | { | | } | K | M | , | . | / | Shift|
* |------+------+------+------+------+------+------+ +------+------+------+------+------+-------------|
* | GUI | Lower| Space| | Enter| Raise| Alt |
* +--------------------/ \--------------------+
*/
[_COLEMAK] = LAYOUT(
KC_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSPC,
KC_LCTL, KC_A, KC_R, KC_S, KC_T, KC_D, KC_ESC, KC_DEL, KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOT,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_LCBR, KC_RCBR, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT,
KC_LGUI, LOWER, KC_SPC, KC_ENT, RAISE, KC_LALT
),
/* Dvorak
* ,-----------------------------------------+ +-----------------------------------------.
* | Tab | " | , | . | P | Y | | F | G | C | R | L | Bksp |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | Ctl | A | O | E | U | I | Esc | | Del | D | H | T | N | S | / |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | Shift| ; | Q | J | K | X | { | | } | B | M | W | V | Z | Shift|
* |------+------+------+------+------+------+------+ +------+------+------+------+------+-------------|
* | GUI | Lower| Space| | Enter| Raise| Alt |
* +--------------------/ \--------------------+
*/
[_DVORAK] = LAYOUT(
KC_TAB, KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y, KC_F, KC_G, KC_C, KC_R, KC_L, KC_BSPC,
KC_LCTL, KC_A, KC_O, KC_E, KC_U, KC_I, KC_ESC, KC_DEL, KC_D, KC_H, KC_T, KC_N, KC_S, KC_SLSH,
KC_LSFT, KC_SCLN, KC_Q, KC_J, KC_K, KC_X, KC_LCBR, KC_RCBR, KC_B, KC_M, KC_W, KC_V, KC_Z, KC_RSFT,
KC_LGUI, LOWER, KC_SPC, KC_ENT, RAISE, KC_LALT
),
/* Lower
* ,-----------------------------------------+ +-----------------------------------------.
* | | ! | @ | # | $ | % | | ^ | & | * | ( | ) | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | | | | | | | | | ` | \ | - | = | [ | ] | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | | | | | | | | | ~ | | | _ | + | { | } | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+-------------|
* | | | | | | | |
* +--------------------/ \--------------------+
*/
[_LOWER] = LAYOUT(
_______, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, _______,
_______, _______, _______, _______, _______, _______, _______, KC_GRV, KC_BSLS, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, _______,
_______, _______, _______, _______, _______, _______, _______, KC_TILD, KC_PIPE, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, _______,
_______, _______, _______, _______, _______, _______
),
/* Raise
* ,-----------------------------------------+ +-----------------------------------------.
* | | 1 | 2 | 3 | 4 | 5 | | | | | | | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | | F1 | F2 | F3 | F4 | F5 | F6 | | | Left | Down | Up |Right | End | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | | F7 | F8 | F9 | F10 | F11 | F12 | | Home | | PgDn | PgUp | | | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+-------------|
* | | | | | | | |
* +--------------------/ \--------------------+
*/
[_RAISE] = LAYOUT(
_______, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, _______,
_______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, XXXXXXX, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, KC_END, _______,
_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_HOME, XXXXXXX, KC_PGDN, KC_PGUP, XXXXXXX, XXXXXXX, _______,
_______, _______, _______, _______, _______, _______
),
/* Adjust
* ,-----------------------------------------+ +-----------------------------------------.
* | | | | | | | | | | | | | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | | | | | | |Qwerty| |Colemk| | | | | | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | | | | | | |Reset | |Dvorak| | | | | | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+-------------|
* | | | | | | | |
* +--------------------/ \--------------------+
*/
[_ADJUST] = LAYOUT(
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, QWERTY, COLEMAK, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, RESET, DVORAK, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______
)
};
uint32_t layer_state_set_user(uint32_t state) {
return update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST);
}
// settings for LED on receiver
void led_init(void) {
DDRD |= (1<<1);
PORTD |= (1<<1);
DDRF |= (1<<4) | (1<<5);
PORTF |= (1<<4) | (1<<5);
}
#define red_led_off PORTF |= (1<<5)
#define red_led_on PORTF &= ~(1<<5)
#define blu_led_off PORTF |= (1<<4)
#define blu_led_on PORTF &= ~(1<<4)
#define grn_led_off PORTD |= (1<<1)
#define grn_led_on PORTD &= ~(1<<1)
#define set_led_off red_led_off; grn_led_off; blu_led_off
#define set_led_red red_led_on; grn_led_off; blu_led_off
#define set_led_blue red_led_off; grn_led_off; blu_led_on
#define set_led_green red_led_off; grn_led_on; blu_led_off
#define set_led_yellow red_led_on; grn_led_on; blu_led_off
#define set_led_magenta red_led_on; grn_led_off; blu_led_on
#define set_led_cyan red_led_off; grn_led_on; blu_led_on
#define set_led_white red_led_on; grn_led_on; blu_led_on
void matrix_init_user(void) {
led_init();
}
void matrix_scan_user(void) {
uint8_t layer = biton32(layer_state);
uint8_t default_layer = biton32(eeconfig_read_default_layer());
switch (layer) {
case _LOWER:
set_led_red;
break;
case _RAISE:
set_led_blue;
break;
case _ADJUST:
set_led_magenta;
break;
default:
switch (default_layer) {
case _COLEMAK:
set_led_white;
break;
case _DVORAK:
set_led_yellow;
break;
default:
set_led_green;
break;
}
break;
}
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
set_single_persistent_default_layer(_QWERTY);
}
break;
case COLEMAK:
if (record->event.pressed) {
set_single_persistent_default_layer(_COLEMAK);
}
break;
case DVORAK:
if (record->event.pressed) {
set_single_persistent_default_layer(_DVORAK);
}
break;
}
return true;
}

View File

@ -0,0 +1,3 @@
## default-led
A keymap that is compatible with mitosis-type receivers, which use RGB LED for layer indication.

View File

@ -0,0 +1,31 @@
/*
This is the c configuration file for the keymap
Copyright 2012 Jun Wako <wakojun@gmail.com>
Copyright 2015 Jack Humbert
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/>.
*/
#ifndef CONFIG_USER_H
#define CONFIG_USER_H
// #include "../../config.h"
/* Use I2C or Serial */
#define USE_I2C
#define SSD1306OLED
#endif

View File

@ -2,6 +2,10 @@
// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
#include QMK_KEYBOARD_H
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
// Each layer gets a name for readability, which is then used in the keymap matrix below.
// The underscores don't mean anything - you can have a layer called STUFF or any other name.
@ -9,13 +13,18 @@
// entirely and just use numbers.
enum comet46_layers
{
_QWERTY,
_LOWER,
_RAISE,
_QWERTY,
_COLEMAK,
_DVORAK,
_LOWER,
_RAISE,
_ADJUST,
};
enum custom_keycodes {
QWERTY = SAFE_RANGE,
COLEMAK,
DVORAK,
LOWER,
RAISE,
};
@ -46,6 +55,42 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
KC_LGUI, LOWER, KC_SPC, KC_ENT, RAISE, KC_LALT
),
/* Colemak
* ,-----------------------------------------+ +-----------------------------------------.
* | Tab | Q | W | F | P | G | | J | L | U | Y | ; | Bksp |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | Ctl | A | R | S | T | D | Esc | | Del | H | N | E | I | O | " |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | { | | } | K | M | , | . | / | Shift|
* |------+------+------+------+------+------+------+ +------+------+------+------+------+-------------|
* | GUI | Lower| Space| | Enter| Raise| Alt |
* +--------------------/ \--------------------+
*/
[_COLEMAK] = LAYOUT(
KC_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSPC,
KC_LCTL, KC_A, KC_R, KC_S, KC_T, KC_D, KC_ESC, KC_DEL, KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOT,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_LCBR, KC_RCBR, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT,
KC_LGUI, LOWER, KC_SPC, KC_ENT, RAISE, KC_LALT
),
/* Dvorak
* ,-----------------------------------------+ +-----------------------------------------.
* | Tab | " | , | . | P | Y | | F | G | C | R | L | Bksp |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | Ctl | A | O | E | U | I | Esc | | Del | D | H | T | N | S | / |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | Shift| ; | Q | J | K | X | { | | } | B | M | W | V | Z | Shift|
* |------+------+------+------+------+------+------+ +------+------+------+------+------+-------------|
* | GUI | Lower| Space| | Enter| Raise| Alt |
* +--------------------/ \--------------------+
*/
[_DVORAK] = LAYOUT(
KC_TAB, KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y, KC_F, KC_G, KC_C, KC_R, KC_L, KC_BSPC,
KC_LCTL, KC_A, KC_O, KC_E, KC_U, KC_I, KC_ESC, KC_DEL, KC_D, KC_H, KC_T, KC_N, KC_S, KC_SLSH,
KC_LSFT, KC_SCLN, KC_Q, KC_J, KC_K, KC_X, KC_LCBR, KC_RCBR, KC_B, KC_M, KC_W, KC_V, KC_Z, KC_RSFT,
KC_LGUI, LOWER, KC_SPC, KC_ENT, RAISE, KC_LALT
),
/* Lower
* ,-----------------------------------------+ +-----------------------------------------.
* | | ! | @ | # | $ | % | | ^ | & | * | ( | ) | |
@ -70,7 +115,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | | F1 | F2 | F3 | F4 | F5 | F6 | | | Left | Down | Up |Right | End | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | | F7 | F8 | F9 | F10 | F11 | F12 | | Home | | | | | | |
* | | F7 | F8 | F9 | F10 | F11 | F12 | | Home | | PgDn | PgUp | | | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+-------------|
* | | | | | | | |
* +--------------------/ \--------------------+
@ -78,26 +123,134 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_RAISE] = LAYOUT(
_______, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, _______,
_______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, XXXXXXX, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, KC_END, _______,
_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_HOME, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______,
_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_HOME, XXXXXXX, KC_PGDN, KC_PGUP, XXXXXXX, XXXXXXX, _______,
_______, _______, _______, _______, _______, _______
),
/* Adjust
* ,-----------------------------------------+ +-----------------------------------------.
* | | | | | | | | | | | | | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | | | | | | |Qwerty| |Colemk| | | | | | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+------+------|
* | | | | | | |Reset | |Dvorak| | | | | | |
* |------+------+------+------+------+------+------+ +------+------+------+------+------+-------------|
* | | | | | | | |
* +--------------------/ \--------------------+
*/
[_ADJUST] = LAYOUT(
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, QWERTY, COLEMAK, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, RESET, DVORAK, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______
)
};
void matrix_scan_user(void) {
uint8_t layer = biton32(layer_state);
switch (layer) {
case _QWERTY:
set_led_green;
break;
case _RAISE:
set_led_blue;
break;
case _LOWER:
set_led_red;
break;
default:
set_led_green;
break;
}
uint32_t layer_state_set_user(uint32_t state) {
return update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST);
}
//SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h
#ifdef SSD1306OLED
// You need to add source files to SRC in rules.mk when using OLED display functions
void set_keylog(uint16_t keycode);
const char *read_keylog(void);
const char *read_modifier_state(void);
const char *read_host_led_state(void);
void matrix_init_user(void) {
iota_gfx_init(false); // turns on the display
}
void matrix_scan_user(void) {
iota_gfx_task(); // this is what updates the display continuously
}
void matrix_update(struct CharacterMatrix *dest, const struct CharacterMatrix *source) {
if (memcmp(dest->display, source->display, sizeof(dest->display))) {
memcpy(dest->display, source->display, sizeof(dest->display));
dest->dirty = true;
}
}
void render_status(struct CharacterMatrix *matrix) {
// Layer state
char layer_str[22];
matrix_write(matrix, "Layer: ");
uint8_t layer = biton32(layer_state);
uint8_t default_layer = biton32(eeconfig_read_default_layer());
switch (layer) {
case _QWERTY:
switch (default_layer) {
case _QWERTY:
snprintf(layer_str, sizeof(layer_str), "Qwerty");
break;
case _COLEMAK:
snprintf(layer_str, sizeof(layer_str), "Colemak");
break;
case _DVORAK:
snprintf(layer_str, sizeof(layer_str), "Dvorak");
break;
default:
snprintf(layer_str, sizeof(layer_str), "Undef-%d", default_layer);
break;
}
break;
case _RAISE:
snprintf(layer_str, sizeof(layer_str), "Raise");
break;
case _LOWER:
snprintf(layer_str, sizeof(layer_str), "Lower");
break;
case _ADJUST:
snprintf(layer_str, sizeof(layer_str), "Adjust");
break;
default:
snprintf(layer_str, sizeof(layer_str), "Undef-%d", layer);
}
matrix_write_ln(matrix, layer_str);
// Last entered keycode
matrix_write_ln(matrix, read_keylog());
// Modifier state
matrix_write_ln(matrix, read_modifier_state());
// Host Keyboard LED Status
matrix_write(matrix, read_host_led_state());
}
void iota_gfx_task_user(void) {
struct CharacterMatrix matrix;
matrix_clear(&matrix);
render_status(&matrix);
matrix_update(&display, &matrix);
}
#endif//SSD1306OLED
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#ifdef SSD1306OLED
if (record->event.pressed) {
set_keylog(keycode);
}
#endif
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
set_single_persistent_default_layer(_QWERTY);
}
break;
case COLEMAK:
if (record->event.pressed) {
set_single_persistent_default_layer(_COLEMAK);
}
break;
case DVORAK:
if (record->event.pressed) {
set_single_persistent_default_layer(_DVORAK);
}
break;
}
return true;
}

View File

@ -0,0 +1,3 @@
## default-oled-display
A keymap that is compatible with receivers with an OLED display.

View File

@ -0,0 +1,5 @@
# If you want to change display settings of the OLED, you need to change the following lines
SRC += ./lib/glcdfont.c \
./lib/keylogger.c \
./lib/modifier_state_reader.c \
./lib/host_led_state_reader.c

View File

@ -10,133 +10,133 @@ static uint8_t send_key_shift_bit[SHIFT_BIT_SIZE];
* Memo: Using other layer keymap to get keycode
*/
void action_pseudo_lut(keyrecord_t *record, uint8_t base_keymap_id, const uint16_t (*keymap)[2]) {
uint8_t prev_shift;
uint16_t keycode;
uint16_t pseudo_keycode;
uint8_t prev_shift;
uint16_t keycode;
uint16_t pseudo_keycode;
/* get keycode from keymap you specified */
keycode = keymap_key_to_keycode(base_keymap_id, record->event.key);
/* get keycode from keymap you specified */
keycode = keymap_key_to_keycode(base_keymap_id, record->event.key);
prev_shift = keyboard_report->mods & (MOD_BIT(KC_LSFT) | MOD_BIT(KC_RSFT));
prev_shift = keyboard_report->mods & (MOD_BIT(KC_LSFT) | MOD_BIT(KC_RSFT));
if (record->event.pressed) {
/* when magic commands entered, keycode does not converted */
if (IS_COMMAND()) {
if (prev_shift) {
add_shift_bit(keycode);
}
register_code(keycode);
return;
}
if (prev_shift) {
pseudo_keycode = convert_keycode(keymap, keycode, true);
dprintf("pressed: %02X, converted: %04X\n", keycode, pseudo_keycode);
add_shift_bit(keycode);
if (IS_LSFT(pseudo_keycode)) {
register_code(QK_LSFT ^ pseudo_keycode);
} else {
/* delete shift mod temporarily */
del_mods(prev_shift);
send_keyboard_report();
register_code(pseudo_keycode);
add_mods(prev_shift);
send_keyboard_report();
}
} else {
pseudo_keycode = convert_keycode(keymap, keycode, false);
dprintf("pressed: %02X, converted: %04X\n", keycode, pseudo_keycode);
if (IS_LSFT(pseudo_keycode)) {
add_weak_mods(MOD_BIT(KC_LSFT));
send_keyboard_report();
register_code(QK_LSFT ^ pseudo_keycode);
/* on Windows, prevent key repeat to avoid unintended output */
unregister_code(QK_LSFT ^ pseudo_keycode);
del_weak_mods(MOD_BIT(KC_LSFT));
send_keyboard_report();
} else {
register_code(pseudo_keycode);
}
}
} else {
if (get_shift_bit(keycode)) {
del_shift_bit(keycode);
pseudo_keycode = convert_keycode(keymap, keycode, true);
} else {
pseudo_keycode = convert_keycode(keymap, keycode, false);
}
dprintf("released: %02X, converted: %04X\n", keycode, pseudo_keycode);
if (IS_LSFT(pseudo_keycode)) {
unregister_code(QK_LSFT ^ pseudo_keycode);
} else {
unregister_code(pseudo_keycode);
}
if (record->event.pressed) {
/* when magic commands entered, keycode does not converted */
if (IS_COMMAND()) {
if (prev_shift) {
add_shift_bit(keycode);
}
register_code(keycode);
return;
}
if (prev_shift) {
pseudo_keycode = convert_keycode(keymap, keycode, true);
dprintf("pressed: %02X, converted: %04X\n", keycode, pseudo_keycode);
add_shift_bit(keycode);
if (IS_LSFT(pseudo_keycode)) {
register_code(QK_LSFT ^ pseudo_keycode);
} else {
/* delete shift mod temporarily */
del_mods(prev_shift);
send_keyboard_report();
register_code(pseudo_keycode);
add_mods(prev_shift);
send_keyboard_report();
}
} else {
pseudo_keycode = convert_keycode(keymap, keycode, false);
dprintf("pressed: %02X, converted: %04X\n", keycode, pseudo_keycode);
if (IS_LSFT(pseudo_keycode)) {
add_weak_mods(MOD_BIT(KC_LSFT));
send_keyboard_report();
register_code(QK_LSFT ^ pseudo_keycode);
/* on Windows, prevent key repeat to avoid unintended output */
unregister_code(QK_LSFT ^ pseudo_keycode);
del_weak_mods(MOD_BIT(KC_LSFT));
send_keyboard_report();
} else {
register_code(pseudo_keycode);
}
}
} else {
if (get_shift_bit(keycode)) {
del_shift_bit(keycode);
pseudo_keycode = convert_keycode(keymap, keycode, true);
} else {
pseudo_keycode = convert_keycode(keymap, keycode, false);
}
dprintf("released: %02X, converted: %04X\n", keycode, pseudo_keycode);
if (IS_LSFT(pseudo_keycode)) {
unregister_code(QK_LSFT ^ pseudo_keycode);
} else {
unregister_code(pseudo_keycode);
}
}
}
uint16_t convert_keycode(const uint16_t (*keymap)[2], uint16_t keycode, bool shift_modded)
{
uint16_t pseudo_keycode;
uint16_t pseudo_keycode;
switch (keycode) {
case KC_A ... KC_CAPSLOCK:
#if defined(__AVR__)
if (shift_modded) {
pseudo_keycode = pgm_read_word(&keymap[keycode][1]);
} else {
pseudo_keycode = pgm_read_word(&keymap[keycode][0]);
}
#else
if (shift_modded) {
pseudo_keycode = keymap[keycode][1];
} else {
pseudo_keycode = keymap[keycode][0];
}
#endif
/* if undefined, use got keycode as it is */
if (pseudo_keycode == 0x00) {
if (shift_modded) {
pseudo_keycode = S(keycode);
} else {
pseudo_keycode = keycode;
}
}
break;
default:
if (shift_modded) {
pseudo_keycode = S(keycode);
} else {
pseudo_keycode = keycode;
}
break;
}
return pseudo_keycode;
switch (keycode) {
case KC_A ... KC_CAPSLOCK:
#if defined(__AVR__)
if (shift_modded) {
pseudo_keycode = pgm_read_word(&keymap[keycode][1]);
} else {
pseudo_keycode = pgm_read_word(&keymap[keycode][0]);
}
#else
if (shift_modded) {
pseudo_keycode = keymap[keycode][1];
} else {
pseudo_keycode = keymap[keycode][0];
}
#endif
/* if undefined, use got keycode as it is */
if (pseudo_keycode == 0x00) {
if (shift_modded) {
pseudo_keycode = S(keycode);
} else {
pseudo_keycode = keycode;
}
}
break;
default:
if (shift_modded) {
pseudo_keycode = S(keycode);
} else {
pseudo_keycode = keycode;
}
break;
}
return pseudo_keycode;
}
uint8_t get_shift_bit(uint16_t keycode) {
if ((keycode >> 3) < SHIFT_BIT_SIZE) {
return send_key_shift_bit[keycode >> 3] & (1 << (keycode & 7));
} else {
dprintf("get_shift_bit: Can't get shift bit. keycode: %02X\n", keycode);
return 0;
}
if ((keycode >> 3) < SHIFT_BIT_SIZE) {
return send_key_shift_bit[keycode >> 3] & (1 << (keycode & 7));
} else {
dprintf("get_shift_bit: Can't get shift bit. keycode: %02X\n", keycode);
return 0;
}
}
void add_shift_bit(uint16_t keycode) {
if ((keycode >> 3) < SHIFT_BIT_SIZE) {
send_key_shift_bit[keycode >> 3] |= (1 << (keycode & 7));
} else {
dprintf("add_shift_bit: Can't add shift bit. keycode: %02X\n", keycode);
}
if ((keycode >> 3) < SHIFT_BIT_SIZE) {
send_key_shift_bit[keycode >> 3] |= (1 << (keycode & 7));
} else {
dprintf("add_shift_bit: Can't add shift bit. keycode: %02X\n", keycode);
}
}
void del_shift_bit(uint16_t keycode) {
if ((keycode >> 3) < SHIFT_BIT_SIZE) {
send_key_shift_bit[keycode >> 3] &= ~(1 << (keycode & 7));
} else {
dprintf("del_shift_bit: Can't delete shift bit. keycode: %02X\n", keycode);
}
if ((keycode >> 3) < SHIFT_BIT_SIZE) {
send_key_shift_bit[keycode >> 3] &= ~(1 << (keycode & 7));
} else {
dprintf("del_shift_bit: Can't delete shift bit. keycode: %02X\n", keycode);
}
}

View File

@ -0,0 +1,34 @@
/*
This is the c configuration file for the keymap
Copyright 2012 Jun Wako <wakojun@gmail.com>
Copyright 2015 Jack Humbert
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/>.
*/
#ifndef CONFIG_USER_H
#define CONFIG_USER_H
/* key combination for command */
#define IS_COMMAND() ( \
keyboard_report->mods == (MOD_BIT(KC_LSFT) | MOD_BIT(KC_RSFT)) \
)
/* Use I2C or Serial */
#define USE_I2C
#define SSD1306OLED
#endif

View File

@ -4,64 +4,96 @@
#include QMK_KEYBOARD_H
#include "keymap_jis2us.h"
#include "action_pseudo_lut.h"
#include "keymap_jp.h"
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
// Each layer gets a name for readability, which is then used in the keymap matrix below.
// The underscores don't mean anything - you can have a layer called STUFF or any other name.
// Layer names don't all need to be of the same length, obviously, and you can also skip them
// entirely and just use numbers.
enum comet46_layers {
_QWERTY,
_LOWER,
_RAISE,
_PSEUDO_US,
_PSEUDO_US_LOWER,
_PSEUDO_US_RAISE,
_ADJUST
_QWERTY,
_LOWER,
_RAISE,
_PSEUDO_US,
_PSEUDO_US_LOWER,
_PSEUDO_US_RAISE,
_ADJUST
};
enum custom_keycodes {
QWERTY = SAFE_RANGE,
PSEUDO_US,
JIS2US,
};
#define KC_LWR MO(_LOWER)
#define KC_RSE MO(_RAISE)
// JIS keycodes
#define KC_JZHT JP_ZHTG // hankaku/zenkaku|kanzi
#define KC_JCIR JP_CIRC // ^, ~
#define KC_JAT JP_AT // @, `
#define KC_JLBR JP_LBRC // [, {
#define KC_JCOL JP_COLN // :, *
#define KC_JRBR JP_RBRC // ], }
#define KC_JBSL JP_BSLS // \, _
#define KC_JMHE JP_MHEN // muhenkan
#define KC_JHEN JP_HENK // henkan
#define KC_JKAN JP_KANA // katakana/hiragana|ro-mazi
#define KC_JMKA JP_MKANA //kana on MacOSX
#define KC_JMEI JP_MEISU //eisu on MacOSX
#define KC_JAMP JP_AMPR // &
#define KC_JQUO JP_QUOT // '
#define KC_JLPR JP_LPRN // (
#define KC_JRPR JP_RPRN // )
#define KC_JEQL JP_EQL // =
#define KC_JTIL JP_TILD // ~
#define KC_JPIP JP_PIPE // |
#define KC_JGRV JP_GRV // `
#define KC_JLCB JP_LCBR // {
#define KC_JPLU JP_PLUS // +
#define KC_JAST JP_ASTR // *
#define KC_JRCB JP_RCBR // }
#define KC_JUND JP_UNDS // _
// Layer related keycodes
#define KC_LWR MO(_LOWER)
#define KC_RSE MO(_RAISE)
#define KC_P_LW MO(_PSEUDO_US_LOWER)
#define KC_P_RS MO(_PSEUDO_US_RAISE)
#define KC_QWRT QWERTY
#define KC_P_US PSEUDO_US
#define KC_J2US JIS2US
// Special keycodes
#define KC_SPCT CTL_T(KC_SPC)
#define KC_ENSF SFT_T(KC_ENT)
#define KC_SFTA SFT_T(KC_A)
#define KC_CTSF S(KC_LCTL)
#define KC_CAEC MT(MOD_LCTL | MOD_LALT, KC_ESC)
#define KC_CSTB C_S_T(KC_TAB)
#define KC_IMON ALT_T(KC_F13)
#define KC_IMOF GUI_T(KC_F14)
#define KC_SRO S(KC_RO)
#define KC_SYEN S(KC_JYEN)
#define KC_CAD LCA(KC_DEL)
#define KC_RST RESET
#define LONGPRESS_DELAY 150
// Fillers to make layering more clear
#define KC_ KC_TRNS
#define KC_ KC_TRNS
#define KC_XXXX KC_NO
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_QWERTY] = LAYOUT_kc(
[_QWERTY] = LAYOUT_kc(
//,----+----+----+----+----+----+ +----+----+----+----+----+----.
ESC , Q , W , E , R , T , Y , U , I , O , P ,DEL ,
CAEC, Q , W , E , R , T , Y , U , I , O , P ,DEL ,
//|----+----+----+----+----+----+----+ +----+----+----+----+----+----+----|
TAB ,SFTA, S , D , F , G ,LPRN, RPRN, H , J , K , L ,SCLN,BSPC,
CSTB, A , S , D , F , G ,LPRN, RPRN, H , J , K , L ,SCLN,BSPC,
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
CTSF, Z , X , C , V , B ,LBRC, RBRC, N , M ,COMM,DOT ,SLSH,QUOT,
LSFT, Z , X , C , V , B ,LBRC, RBRC, N , M ,COMM,DOT ,SLSH,QUOT,
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
IMOF,LWR ,SPCT, ENSF,RSE ,IMON
// +----+----+---/ \---+----+----+
),
[_LOWER] = LAYOUT_kc(
[_LOWER] = LAYOUT_kc(
//,----+----+----+----+----+----+ +----+----+----+----+----+----.
,EXLM, AT ,HASH,DLR ,PERC, CIRC,AMPR,ASTR,LPRN,RPRN, ,
//|----+----+----+----+----+----+----+ +----+----+----+----+----+----+----|
@ -69,60 +101,60 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
, F7 , F8 , F9 , F10, F11, F12, TILD,PIPE,UNDS,PLUS,LCBR,RCBR, ,
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
, , , , ,
, , , , ,
// +----+----+---/ \---+----+----+
),
[_RAISE] = LAYOUT_kc(
[_RAISE] = LAYOUT_kc(
//,----+----+----+----+----+----+ +----+----+----+----+----+----.
, 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 0 , ,
//|----+----+----+----+----+----+----+ +----+----+----+----+----+----+----|
, , , , , , , XXXX,LEFT,DOWN, UP ,RGHT,END , ,
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
, , , , , , , HOME,XXXX,XXXX,XXXX,XXXX,XXXX, ,
, , , , , , , HOME,XXXX,PGDN,PGUP,XXXX,XXXX, ,
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
, , , , ,
, , , , ,
// +----+----+---/ \---+----+----+
),
[_PSEUDO_US] = LAYOUT_kc(
[_PSEUDO_US] = LAYOUT_kc(
//,----+----+----+----+----+----+ +----+----+----+----+----+----.
ESC , Q , W , E , R , T , Y , U , I , O , P ,DEL ,
CAEC, Q , W , E , R , T , Y , U , I , O , P ,DEL ,
//|----+----+----+----+----+----+----+ +----+----+----+----+----+----+----|
TAB ,SFTA, S , D , F , G ,ASTR, LPRN, H , J , K , L ,FN0 ,BSPC,
CSTB, A , S , D , F , G ,JLPR, JRPR, H , J , K , L ,J2US,BSPC,
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
CTSF, Z , X , C , V , B ,FN0 , FN0 , N , M ,COMM,DOT ,SLSH,FN0 ,
LSFT, Z , X , C , V , B ,J2US, J2US, N , M ,COMM,DOT ,SLSH,J2US,
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
IMOF,P_LW,SPCT, ENSF,P_RS,IMON
// +----+----+---/ \---+----+----+
),
[_PSEUDO_US_LOWER] = LAYOUT_kc(
[_PSEUDO_US_LOWER] = LAYOUT_kc(
//,----+----+----+----+----+----+ +----+----+----+----+----+----.
,EXLM,LBRC,HASH,DLR ,PERC, EQL ,CIRC, DQT,ASTR,LPRN, ,
,EXLM,JAT ,HASH,DLR ,PERC, JCIR,JAMP,JAST,JLPR,JRPR, ,
//|----+----+----+----+----+----+----+ +----+----+----+----+----+----+----|
, F1 , F2 , F3 , F4 , F5 , F6 , LCBR,JYEN,MINS,UNDS,RBRC,BSLS, ,
, F1 , F2 , F3 , F4 , F5 , F6 , JGRV,JBSL,MINS,JEQL,JLBR,JRBR, ,
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
, F7 , F8 , F9 , F10, F11, F12, PLUS,SYEN,SRO ,COLN,RCBR,PIPE, ,
, F7 , F8 , F9 , F10, F11, F12, JTIL,JPIP,JUND,JPLU,JLCB,JRCB, ,
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
, , , , ,
, , , , ,
// +----+----+---/ \---+----+----+
),
[_PSEUDO_US_RAISE] = LAYOUT_kc(
[_PSEUDO_US_RAISE] = LAYOUT_kc(
//,----+----+----+----+----+----+ +----+----+----+----+----+----.
, 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 0 , ,
//|----+----+----+----+----+----+----+ +----+----+----+----+----+----+----|
, , , , , , GRV, XXXX,LEFT,DOWN, UP ,RGHT,END , ,
, , , , , ,JZHT, XXXX,LEFT,DOWN, UP ,RGHT,END , ,
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
, , , , , , , HOME,XXXX,XXXX,XXXX,XXXX,XXXX, ,
, , , , , , , HOME,XXXX,PGDN,PGUP,XXXX,XXXX, ,
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
, , , , ,
, , , , ,
// +----+----+---/ \---+----+----+
),
[_ADJUST] = LAYOUT_kc(
[_ADJUST] = LAYOUT_kc(
//,----+----+----+----+----+----+ +----+----+----+----+----+----.
, , , , , , , , , , , ,
//|----+----+----+----+----+----+----+ +----+----+----+----+----+----+----|
@ -130,69 +162,16 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
, , , , , ,RST , P_US, , , , , , ,
//|----+----+----+----+----+----+----| |----+----+----+----+----+----+----|
, , , , ,
, , , , ,
// +----+----+---/ \---+----+----+
)
};
/*
* user defined action function
*/
enum function_id {
PSEUDO_US_FUNCTION,
};
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
switch (id)
{
case PSEUDO_US_FUNCTION:
action_pseudo_lut(record, _QWERTY, keymap_jis2us);
break;
}
}
/*
* Fn action definition
*/
const uint16_t PROGMEM fn_actions[] = {
[0] = ACTION_FUNCTION(PSEUDO_US_FUNCTION),
};
void matrix_scan_user(void) {
uint8_t layer = biton32(layer_state);
switch (layer) {
case _LOWER:
set_led_red;
break;
case _RAISE:
set_led_blue;
break;
case _PSEUDO_US_LOWER:
set_led_yellow;
break;
case _PSEUDO_US_RAISE:
set_led_cyan;
break;
case _ADJUST:
set_led_magenta;
break;
default:
set_led_green;
break;
}
};
uint32_t layer_state_set_user(uint32_t state) {
switch (biton32(state)) {
case _PSEUDO_US:
return update_tri_layer_state(state, _PSEUDO_US_RAISE, _PSEUDO_US_LOWER, _ADJUST);
break;
case _PSEUDO_US_LOWER:
return update_tri_layer_state(state, _PSEUDO_US_RAISE, _PSEUDO_US_LOWER, _ADJUST);
break;
case _PSEUDO_US_RAISE:
case _PSEUDO_US_RAISE:
return update_tri_layer_state(state, _PSEUDO_US_RAISE, _PSEUDO_US_LOWER, _ADJUST);
break;
default:
@ -201,19 +180,112 @@ uint32_t layer_state_set_user(uint32_t state) {
}
}
//SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h
#ifdef SSD1306OLED
// You need to add source files to SRC in rules.mk when using OLED display functions
void set_keylog(uint16_t keycode);
const char *read_keylog(void);
const char *read_modifier_state(void);
const char *read_host_led_state(void);
void matrix_init_user(void) {
iota_gfx_init(false); // turns on the display
}
void matrix_scan_user(void) {
iota_gfx_task(); // this is what updates the display continuously
}
void matrix_update(struct CharacterMatrix *dest, const struct CharacterMatrix *source) {
if (memcmp(dest->display, source->display, sizeof(dest->display))) {
memcpy(dest->display, source->display, sizeof(dest->display));
dest->dirty = true;
}
}
void render_status(struct CharacterMatrix *matrix) {
// Layer state
char layer_str[22];
matrix_write(matrix, "Layer: ");
uint8_t layer = biton32(layer_state);
uint8_t default_layer = biton32(eeconfig_read_default_layer());
switch (layer) {
case _QWERTY:
switch (default_layer) {
case _QWERTY:
snprintf(layer_str, sizeof(layer_str), "Qwerty");
break;
case _PSEUDO_US:
snprintf(layer_str, sizeof(layer_str), "Psuedo_US");
break;
default:
snprintf(layer_str, sizeof(layer_str), "Undef-%d", default_layer);
break;
}
break;
case _RAISE:
snprintf(layer_str, sizeof(layer_str), "Raise");
break;
case _LOWER:
snprintf(layer_str, sizeof(layer_str), "Lower");
break;
case _PSEUDO_US_RAISE:
snprintf(layer_str, sizeof(layer_str), "P_US_Raise");
break;
case _PSEUDO_US_LOWER:
snprintf(layer_str, sizeof(layer_str), "P_US_Lower");
break;
case _ADJUST:
snprintf(layer_str, sizeof(layer_str), "Adjust");
break;
default:
snprintf(layer_str, sizeof(layer_str), "Undef-%d", layer);
}
matrix_write_ln(matrix, layer_str);
// Last entered keycode
matrix_write_ln(matrix, read_keylog());
// Modifier state
matrix_write_ln(matrix, read_modifier_state());
// Host Keyboard LED Status
matrix_write(matrix, read_host_led_state());
}
void iota_gfx_task_user(void) {
struct CharacterMatrix matrix;
#if DEBUG_TO_SCREEN
if (debug_enable) {
return;
}
#endif
matrix_clear(&matrix);
render_status(&matrix);
matrix_update(&display, &matrix);
}
#endif//SSD1306OLED
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#ifdef SSD1306OLED
if (record->event.pressed) {
set_keylog(keycode);
}
#endif
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
set_single_persistent_default_layer(_QWERTY);
}
return false;
break;
case PSEUDO_US:
if (record->event.pressed) {
set_single_persistent_default_layer(_PSEUDO_US);
}
return false;
break;
case JIS2US:
action_pseudo_lut(record, _QWERTY, keymap_jis2us);
break;
}
return true;

View File

@ -3,30 +3,30 @@
/* keymap for convert from JIS to US */
const uint16_t PROGMEM keymap_jis2us[][2] = {
[KC_A ... KC_CAPS] = { 0x00, 0x00 }, /* default value */
[KC_A ... KC_CAPS] = { 0x00, 0x00 }, /* default value */
[KC_1] = { KC_1, KC_EXLM }, /* 1 and ! -> 1 and ! */
[KC_2] = { KC_2, KC_LBRC }, /* 2 and " -> 2 and @ */
[KC_3] = { KC_3, KC_HASH }, /* 3 and # -> 3 and # */
[KC_4] = { KC_4, KC_DLR }, /* 4 and $ -> 4 and $ */
[KC_5] = { KC_5, KC_PERC }, /* 5 and % -> 5 and % */
[KC_6] = { KC_6, KC_EQL }, /* 6 and & -> 6 and ^ */
[KC_7] = { KC_7, KC_CIRC }, /* 7 and ' -> 7 and & */
[KC_8] = { KC_8, KC_DQT }, /* 8 and ( -> 8 and * */
[KC_9] = { KC_9, KC_ASTR }, /* 9 and ) -> 9 and ( */
[KC_0] = { KC_0, KC_LPRN }, /* 0 and (no assign) -> 0 and ) */
[KC_MINS] = { KC_MINS, S(KC_RO) }, /* - and = -> - and _ */
[KC_EQL] = { KC_UNDS, KC_COLN }, /* ^ and ~ -> = and + */
[KC_LBRC] = { KC_RBRC, KC_RCBR }, /* @ and ` -> [ and { */
[KC_RBRC] = { KC_BSLS, KC_PIPE }, /* [ and { -> ] and } */
[KC_BSLS] = { KC_JYEN, S(KC_JYEN) }, /* ] and } -> / and | */
[KC_NUHS] = { KC_NUHS, S(KC_NUHS) }, /* (no assign) */
[KC_SCLN] = { KC_SCLN, KC_QUOT }, /* ; and + -> ; and : */
[KC_QUOT] = { KC_AMPR, KC_AT }, /* : and * -> ' and " */
[KC_GRV] = { KC_LCBR, KC_PLUS }, /* (no assign) -> ` and ~ */
[KC_COMM] = { KC_COMM, KC_LT }, /* , and < -> , and < */
[KC_DOT] = { KC_DOT, KC_GT }, /* . and > -> . and > */
[KC_SLSH] = { KC_SLSH, KC_QUES }, /* / and ? -> / and ? */
[KC_1] = { KC_1, KC_EXLM }, /* 1 and ! -> 1 and ! */
[KC_2] = { KC_2, KC_LBRC }, /* 2 and " -> 2 and @ */
[KC_3] = { KC_3, KC_HASH }, /* 3 and # -> 3 and # */
[KC_4] = { KC_4, KC_DLR }, /* 4 and $ -> 4 and $ */
[KC_5] = { KC_5, KC_PERC }, /* 5 and % -> 5 and % */
[KC_6] = { KC_6, KC_EQL }, /* 6 and & -> 6 and ^ */
[KC_7] = { KC_7, KC_CIRC }, /* 7 and ' -> 7 and & */
[KC_8] = { KC_8, KC_DQT }, /* 8 and ( -> 8 and * */
[KC_9] = { KC_9, KC_ASTR }, /* 9 and ) -> 9 and ( */
[KC_0] = { KC_0, KC_LPRN }, /* 0 and (no assign) -> 0 and ) */
[KC_MINS] = { KC_MINS, S(KC_RO) }, /* - and = -> - and _ */
[KC_EQL] = { KC_UNDS, KC_COLN }, /* ^ and ~ -> = and + */
[KC_LBRC] = { KC_RBRC, KC_RCBR }, /* @ and ` -> [ and { */
[KC_RBRC] = { KC_BSLS, KC_PIPE }, /* [ and { -> ] and } */
[KC_BSLS] = { KC_JYEN, S(KC_JYEN) }, /* ] and } -> / and | */
[KC_NUHS] = { KC_NUHS, S(KC_NUHS) }, /* (no assign) */
[KC_SCLN] = { KC_SCLN, KC_QUOT }, /* ; and + -> ; and : */
[KC_QUOT] = { KC_AMPR, KC_AT }, /* : and * -> ' and " */
[KC_GRV] = { KC_LCBR, KC_PLUS }, /* (no assign) -> ` and ~ */
[KC_COMM] = { KC_COMM, KC_LT }, /* , and < -> , and < */
[KC_DOT] = { KC_DOT, KC_GT }, /* . and > -> . and > */
[KC_SLSH] = { KC_SLSH, KC_QUES }, /* / and ? -> / and ? */
};
#endif

View File

@ -1,26 +1,7 @@
SRC += action_pseudo_lut.c
# Build Options
# change to "no" to disable the options, or define them in the Makefile in
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = no # Mouse keys(+4700)
EXTRAKEY_ENABLE = no # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400)
COMMAND_ENABLE = no # Commands for debug and configuration
NKRO_ENABLE = no # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
MIDI_ENABLE = no # MIDI controls
AUDIO_ENABLE = no # Audio output on port C6
UNICODE_ENABLE = no # Unicode
BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight.
ONEHAND_ENABLE = no # Enable one-hand typing
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
ifndef QUANTUM_DIR
include ../../../../Makefile
endif
# If you want to change display settings of the OLED, you need to change the following lines
SRC += ./lib/glcdfont.c \
./lib/keylogger.c \
./lib/modifier_state_reader.c \
./lib/host_led_state_reader.c

View File

@ -0,0 +1,148 @@
// This is the 'classic' fixed-space bitmap font for Adafruit_GFX since 1.0.
// See gfxfont.h for newer custom bitmap font info.
#ifndef FONT5X7_H
#define FONT5X7_H
#ifdef __AVR__
#include <avr/io.h>
#include <avr/pgmspace.h>
#elif defined(ESP8266)
#include <pgmspace.h>
#else
#define PROGMEM
#endif
// Standard ASCII 5x7 font
const unsigned char font[] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 0x00,
0x3E, 0x6B, 0x4F, 0x6B, 0x3E, 0x00,
0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 0x00,
0x18, 0x3C, 0x7E, 0x3C, 0x18, 0x00,
0x1C, 0x57, 0x7D, 0x57, 0x1C, 0x00,
0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 0x00,
0x00, 0x18, 0x3C, 0x18, 0x00, 0x00,
0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 0x00,
0x00, 0x18, 0x24, 0x18, 0x00, 0x00,
0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 0x00,
0x30, 0x48, 0x3A, 0x06, 0x0E, 0x00,
0x26, 0x29, 0x79, 0x29, 0x26, 0x00,
0x40, 0x7F, 0x05, 0x05, 0x07, 0x00,
0x40, 0x7F, 0x05, 0x25, 0x3F, 0x00,
0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 0x00,
0x7F, 0x3E, 0x1C, 0x1C, 0x08, 0x00,
0x08, 0x1C, 0x1C, 0x3E, 0x7F, 0x00,
0x14, 0x22, 0x7F, 0x22, 0x14, 0x00,
0x5F, 0x5F, 0x00, 0x5F, 0x5F, 0x00,
0x06, 0x09, 0x7F, 0x01, 0x7F, 0x00,
0x00, 0x66, 0x89, 0x95, 0x6A, 0x00,
0x60, 0x60, 0x60, 0x60, 0x60, 0x00,
0x94, 0xA2, 0xFF, 0xA2, 0x94, 0x00,
0x08, 0x04, 0x7E, 0x04, 0x08, 0x00,
0x10, 0x20, 0x7E, 0x20, 0x10, 0x00,
0x08, 0x08, 0x2A, 0x1C, 0x08, 0x00,
0x08, 0x1C, 0x2A, 0x08, 0x08, 0x00,
0x1E, 0x10, 0x10, 0x10, 0x10, 0x00,
0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 0x00,
0x30, 0x38, 0x3E, 0x38, 0x30, 0x00,
0x06, 0x0E, 0x3E, 0x0E, 0x06, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x5F, 0x00, 0x00, 0x00,
0x00, 0x07, 0x00, 0x07, 0x00, 0x00,
0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00,
0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00,
0x23, 0x13, 0x08, 0x64, 0x62, 0x00,
0x36, 0x49, 0x56, 0x20, 0x50, 0x00,
0x00, 0x08, 0x07, 0x03, 0x00, 0x00,
0x00, 0x1C, 0x22, 0x41, 0x00, 0x00,
0x00, 0x41, 0x22, 0x1C, 0x00, 0x00,
0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00,
0x08, 0x08, 0x3E, 0x08, 0x08, 0x00,
0x00, 0x80, 0x70, 0x30, 0x00, 0x00,
0x08, 0x08, 0x08, 0x08, 0x08, 0x00,
0x00, 0x00, 0x60, 0x60, 0x00, 0x00,
0x20, 0x10, 0x08, 0x04, 0x02, 0x00,
0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00,
0x00, 0x42, 0x7F, 0x40, 0x00, 0x00,
0x72, 0x49, 0x49, 0x49, 0x46, 0x00,
0x21, 0x41, 0x49, 0x4D, 0x33, 0x00,
0x18, 0x14, 0x12, 0x7F, 0x10, 0x00,
0x27, 0x45, 0x45, 0x45, 0x39, 0x00,
0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00,
0x41, 0x21, 0x11, 0x09, 0x07, 0x00,
0x36, 0x49, 0x49, 0x49, 0x36, 0x00,
0x46, 0x49, 0x49, 0x29, 0x1E, 0x00,
0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x00, 0x40, 0x34, 0x00, 0x00, 0x00,
0x00, 0x08, 0x14, 0x22, 0x41, 0x00,
0x14, 0x14, 0x14, 0x14, 0x14, 0x00,
0x00, 0x41, 0x22, 0x14, 0x08, 0x00,
0x02, 0x01, 0x59, 0x09, 0x06, 0x00,
0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00,
0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00,
0x7F, 0x49, 0x49, 0x49, 0x36, 0x00,
0x3E, 0x41, 0x41, 0x41, 0x22, 0x00,
0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00,
0x7F, 0x49, 0x49, 0x49, 0x41, 0x00,
0x7F, 0x09, 0x09, 0x09, 0x01, 0x00,
0x3E, 0x41, 0x41, 0x51, 0x73, 0x00,
0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00,
0x00, 0x41, 0x7F, 0x41, 0x00, 0x00,
0x20, 0x40, 0x41, 0x3F, 0x01, 0x00,
0x7F, 0x08, 0x14, 0x22, 0x41, 0x00,
0x7F, 0x40, 0x40, 0x40, 0x40, 0x00,
0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00,
0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00,
0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00,
0x7F, 0x09, 0x09, 0x09, 0x06, 0x00,
0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00,
0x7F, 0x09, 0x19, 0x29, 0x46, 0x00,
0x26, 0x49, 0x49, 0x49, 0x32, 0x00,
0x03, 0x01, 0x7F, 0x01, 0x03, 0x00,
0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00,
0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00,
0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00,
0x63, 0x14, 0x08, 0x14, 0x63, 0x00,
0x03, 0x04, 0x78, 0x04, 0x03, 0x00,
0x61, 0x59, 0x49, 0x4D, 0x43, 0x00,
0x00, 0x7F, 0x41, 0x41, 0x41, 0x00,
0x02, 0x04, 0x08, 0x10, 0x20, 0x00,
0x00, 0x41, 0x41, 0x41, 0x7F, 0x00,
0x04, 0x02, 0x01, 0x02, 0x04, 0x00,
0x40, 0x40, 0x40, 0x40, 0x40, 0x00,
0x00, 0x03, 0x07, 0x08, 0x00, 0x00,
0x20, 0x54, 0x54, 0x78, 0x40, 0x00,
0x7F, 0x28, 0x44, 0x44, 0x38, 0x00,
0x38, 0x44, 0x44, 0x44, 0x28, 0x00,
0x38, 0x44, 0x44, 0x28, 0x7F, 0x00,
0x38, 0x54, 0x54, 0x54, 0x18, 0x00,
0x00, 0x08, 0x7E, 0x09, 0x02, 0x00,
0x18, 0xA4, 0xA4, 0x9C, 0x78, 0x00,
0x7F, 0x08, 0x04, 0x04, 0x78, 0x00,
0x00, 0x44, 0x7D, 0x40, 0x00, 0x00,
0x20, 0x40, 0x40, 0x3D, 0x00, 0x00,
0x7F, 0x10, 0x28, 0x44, 0x00, 0x00,
0x00, 0x41, 0x7F, 0x40, 0x00, 0x00,
0x7C, 0x04, 0x78, 0x04, 0x78, 0x00,
0x7C, 0x08, 0x04, 0x04, 0x78, 0x00,
0x38, 0x44, 0x44, 0x44, 0x38, 0x00,
0xFC, 0x18, 0x24, 0x24, 0x18, 0x00,
0x18, 0x24, 0x24, 0x18, 0xFC, 0x00,
0x7C, 0x08, 0x04, 0x04, 0x08, 0x00,
0x48, 0x54, 0x54, 0x54, 0x24, 0x00,
0x04, 0x04, 0x3F, 0x44, 0x24, 0x00,
0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00,
0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00,
0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00,
0x44, 0x28, 0x10, 0x28, 0x44, 0x00,
0x4C, 0x90, 0x90, 0x90, 0x7C, 0x00,
0x44, 0x64, 0x54, 0x4C, 0x44, 0x00,
0x00, 0x08, 0x36, 0x41, 0x00, 0x00,
0x00, 0x00, 0x77, 0x00, 0x00, 0x00,
0x00, 0x41, 0x36, 0x08, 0x00, 0x00,
0x02, 0x01, 0x02, 0x04, 0x02, 0x00,
0x3C, 0x26, 0x23, 0x26, 0x3C, 0x00
};
#endif // FONT5X7_H

View File

@ -0,0 +1,15 @@
#include <stdio.h>
#include "comet46.h"
char host_led_state_str[22];
const char *read_host_led_state(void) {
uint8_t leds = host_keyboard_leds();
snprintf(host_led_state_str, sizeof(host_led_state_str), "Lock: %s%s%s",
(leds & (1 << USB_LED_CAPS_LOCK)) ? "CAPL " : "",
(leds & (1 << USB_LED_SCROLL_LOCK)) ? "SCRL " : "",
(leds & (1 << USB_LED_NUM_LOCK)) ? "NUML" : "");
return host_led_state_str;
}

View File

@ -0,0 +1,294 @@
#include <stdio.h>
#ifdef __AVR__
#include <avr/io.h>
#include <avr/pgmspace.h>
#else
#define PROGMEM
#endif
#define NUM_USB_HID_KEYCODES 255
#define LEN_KEYCODE_STR 4
char keylog[22] = {"KC: ID: "};
// Quick and dirty way to display USB HID keycodes used in QMK
// USB HID keycodes from 0x0000 to 0x00FF are stored in a 4x256+1 length char
const char code_to_name[] PROGMEM = {
"NO " //0x00
"TRNS"
"? "
"? "
"A "
"B "
"C "
"D "
"E "
"F "
"G "
"H "
"I "
"J "
"K "
"L "
"M " //0x10
"N "
"O "
"P "
"Q "
"R "
"S "
"T "
"U "
"V "
"W "
"X "
"Y "
"Z "
"1 "
"2 "
"3 " //0x20
"4 "
"5 "
"6 "
"7 "
"8 "
"9 "
"0 "
"ENT "
"ESC "
"BSPC"
"TAB "
"SPC "
"MINS"
"EQL "
"LBRC"
"RBRC" //0x30
"BSLS"
"NUHS"
"SCLN"
"QUOT"
"GRV "
"COMM"
"DOT "
"SLSH"
"CAPS"
"F1 "
"F2 "
"F3 "
"F4 "
"F5 "
"F6 "
"F7 " //0x40
"F8 "
"F9 "
"F10 "
"F11 "
"F12 "
"PSCR"
"SLCK"
"PAUS"
"INS "
"HOME"
"PGUP"
"DEL "
"END "
"PGDN"
"RGHT"
"LEFT" //0x50
"DOWN"
"UP "
"NLCK"
"PSLS"
"PAST"
"PMNS"
"PPLS"
"PENT"
"P1 "
"P2 "
"P3 "
"P4 "
"P5 "
"P6 "
"P7 "
"P8 " //0x60
"P9 "
"P0 "
"PDOT"
"NUBS"
"APP "
"POW "
"PEQL"
"F13 "
"F14 "
"F15 "
"F16 "
"F17 "
"F18 "
"F19 "
"F20 "
"F21 " //0x70
"F22 "
"F23 "
"F24 "
"EXEC"
"HELP"
"MENU"
"SLCT"
"STOP"
"AGIN"
"UNDO"
"CUT "
"COPY"
"PSTE"
"FIND"
"_MUT"
"_VUP" //0x80
"_VDN"
"LCAP"
"LNUM"
"LSCR"
"PCMM"
"PEQA"
"INT1"
"INT2"
"INT3"
"INT4"
"INT5"
"INT6"
"INT7"
"INT8"
"INT9"
"LAN1" //0x90
"LAN2"
"LAN3"
"LAN4"
"LAN5"
"LAN6"
"LAN7"
"LAN8"
"LAN9"
"ERAS"
"SYSR"
"CNCL"
"CLR "
"PRIR"
"RTRN"
"SEP "
"OUT " //0xA0
"OPER"
"CLRA"
"CSEL"
"ESEL"
"PWR " //0xA5
"SLEP"
"WAKE"
"MUTE"
"VOLU"
"VOLD"
"MNXT"
"MPRV"
"MSTP"
"MPLY"
"MSEL"
"EJCT" //0xB0
"MAIL"
"CALC"
"MYCM"
"WSCH"
"WHOM"
"WBAK"
"WFWD"
"WSTP"
"WREF"
"WFAV"
"MFFD"
"MRWD"
"BRIU"
"BRID"
"? "
"FN0 " //0xC0
"FN1 "
"FN2 "
"FN3 "
"FN4 "
"FN5 "
"FN6 "
"FN7 "
"FN8 "
"FN9 "
"FN10"
"FN11"
"FN12"
"FN13"
"FN14"
"FN15"
"FN16" //0xD0
"FN17"
"FN18"
"FN19"
"FN20"
"FN21"
"FN22"
"FN23"
"FN24"
"FN25"
"FN26"
"FN27"
"FN28"
"FN29"
"FN30"
"FN31"
"LCTL" //0xE0
"LSFT"
"LALT"
"LGUI"
"RCTL"
"RSFT"
"RALT"
"RGUI"
"? "
"? "
"? "
"? "
"? "
"? "
"? "
"? "
"MS_U" //0xF0
"MS_D"
"MS_L"
"MS_R"
"BTN1"
"BTN2"
"BTN3"
"BTN4"
"BTN5"
"WH_U"
"WH_D"
"WH_L"
"WH_R"
"ACL0"
"ACL1"
"ACL2"
};
void set_keylog(uint16_t keycode)
{
char name[LEN_KEYCODE_STR+1] = "? ";
if (keycode <= NUM_USB_HID_KEYCODES) {
for (uint8_t k = 0; k < LEN_KEYCODE_STR; k++) {
name[k] = pgm_read_byte_near(code_to_name + keycode * LEN_KEYCODE_STR + k);
}
} else if (keycode > NUM_USB_HID_KEYCODES) {
snprintf(name, sizeof(name), "QMK ");
}
// update keylog
snprintf(keylog, sizeof(keylog), "KC: %s ID: %d", name, keycode);
}
const char *read_keylog(void) {
return keylog;
}

View File

@ -0,0 +1,18 @@
#include <stdio.h>
#include "comet46.h"
char modifier_state_str[22];
const char *read_modifier_state(void) {
uint8_t modifiers = get_mods();
uint8_t one_shot = get_oneshot_mods();
snprintf(modifier_state_str, sizeof(modifier_state_str), "Mod: %s%s%s%s",
(modifiers & MODS_CTRL_MASK || one_shot & MODS_CTRL_MASK) ? "CTL " : "",
(modifiers & MODS_GUI_MASK || one_shot & MODS_GUI_MASK) ? "GUI " : "",
(modifiers & MODS_ALT_MASK || one_shot & MODS_ALT_MASK) ? "ALT " : "",
(modifiers & MODS_SHIFT_MASK || one_shot & MODS_SHIFT_MASK) ? "SFT" : ""
);
return modifier_state_str;
}

View File

@ -1,6 +1,6 @@
# Comet46
![Comet46](https://user-images.githubusercontent.com/39004890/42418180-d5bb188c-82d5-11e8-99fa-65020ce5ac5d.jpg)
![Comet46](https://user-images.githubusercontent.com/39004890/50396817-a1660600-07af-11e9-8611-3156c635db43.jpg)
A split wireless 40% column-staggered keyboard
@ -13,4 +13,5 @@ Make example for this keyboard (after setting up your build environment):
make comet46:default
See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
See [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) then the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information.

View File

@ -1,12 +1,8 @@
OPT_DEFS += -DCOMET46_ORTHO_===PROMICRO
COMET46_UPLOAD_COMMAND = while [ ! -r $(USB) ]; do sleep 1; done; \
avrdude -p $(MCU) -c avr109 -U flash:w:$(TARGET).hex -P $(USB)
# # project specific files
SRC = matrix.c
SRC += matrix.c \
i2c.c \
ssd1306.c
# MCU name
#MCU = at90usb1287
MCU = atmega32u4
@ -24,8 +20,6 @@ MCU = atmega32u4
# software delays.
F_CPU = 16000000
#
# LUFA specific
#
# Target architecture (see library "Board Types" documentation).
@ -48,7 +42,7 @@ F_USB = $(F_CPU)
# This definition is optional, and if your keyboard supports multiple bootloaders of
# different sizes, comment this out, and the correct address will be loaded
# automatically (+60). See bootloader.mk for all options.
BOOTLOADER = caterina
# BOOTLOADER = caterina
# Interrupt driven control endpoint task(+60)
OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT

344
keyboards/comet46/ssd1306.c Normal file
View File

@ -0,0 +1,344 @@
#ifdef SSD1306OLED
#include "ssd1306.h"
#include "i2c.h"
#include <string.h>
#include "print.h"
#ifdef ADAFRUIT_BLE_ENABLE
#include "adafruit_ble.h"
#endif
#ifdef PROTOCOL_LUFA
#include "lufa.h"
#endif
#include "sendchar.h"
#include "timer.h"
static const unsigned char font[] PROGMEM;
// Set this to 1 to help diagnose early startup problems
// when testing power-on with ble. Turn it off otherwise,
// as the latency of printing most of the debug info messes
// with the matrix scan, causing keys to drop.
#define DEBUG_TO_SCREEN 0
//static uint16_t last_battery_update;
//static uint32_t vbat;
//#define BatteryUpdateInterval 10000 /* milliseconds */
// 'last_flush' is declared as uint16_t,
// so this must be less than 65535
#define ScreenOffInterval 60000 /* milliseconds */
#if DEBUG_TO_SCREEN
static uint8_t displaying;
#endif
static uint16_t last_flush;
static bool force_dirty = true;
// Write command sequence.
// Returns true on success.
static inline bool _send_cmd1(uint8_t cmd) {
bool res = false;
if (i2c_start_write(SSD1306_ADDRESS)) {
xprintf("failed to start write to %d\n", SSD1306_ADDRESS);
goto done;
}
if (i2c_master_write(0x0 /* command byte follows */)) {
print("failed to write control byte\n");
goto done;
}
if (i2c_master_write(cmd)) {
xprintf("failed to write command %d\n", cmd);
goto done;
}
res = true;
done:
i2c_master_stop();
return res;
}
// Write 2-byte command sequence.
// Returns true on success
static inline bool _send_cmd2(uint8_t cmd, uint8_t opr) {
if (!_send_cmd1(cmd)) {
return false;
}
return _send_cmd1(opr);
}
// Write 3-byte command sequence.
// Returns true on success
static inline bool _send_cmd3(uint8_t cmd, uint8_t opr1, uint8_t opr2) {
if (!_send_cmd1(cmd)) {
return false;
}
if (!_send_cmd1(opr1)) {
return false;
}
return _send_cmd1(opr2);
}
#define send_cmd1(c) if (!_send_cmd1(c)) {goto done;}
#define send_cmd2(c,o) if (!_send_cmd2(c,o)) {goto done;}
#define send_cmd3(c,o1,o2) if (!_send_cmd3(c,o1,o2)) {goto done;}
static void clear_display(void) {
matrix_clear(&display);
// Clear all of the display bits (there can be random noise
// in the RAM on startup)
send_cmd3(PageAddr, 0, (DisplayHeight / 8) - 1);
send_cmd3(ColumnAddr, 0, DisplayWidth - 1);
if (i2c_start_write(SSD1306_ADDRESS)) {
goto done;
}
if (i2c_master_write(0x40)) {
// Data mode
goto done;
}
for (uint8_t row = 0; row < MatrixRows; ++row) {
for (uint8_t col = 0; col < DisplayWidth; ++col) {
i2c_master_write(0);
}
}
display.dirty = false;
done:
i2c_master_stop();
}
#if DEBUG_TO_SCREEN
#undef sendchar
static int8_t capture_sendchar(uint8_t c) {
sendchar(c);
iota_gfx_write_char(c);
if (!displaying) {
iota_gfx_flush();
}
return 0;
}
#endif
bool iota_gfx_init(bool rotate) {
bool success = false;
i2c_master_init();
send_cmd1(DisplayOff);
send_cmd2(SetDisplayClockDiv, 0x80);
send_cmd2(SetMultiPlex, DisplayHeight - 1);
send_cmd2(SetDisplayOffset, 0);
send_cmd1(SetStartLine | 0x0);
send_cmd2(SetChargePump, 0x14 /* Enable */);
send_cmd2(SetMemoryMode, 0 /* horizontal addressing */);
if(rotate){
// the following Flip the display orientation 180 degrees
send_cmd1(SegRemap);
send_cmd1(ComScanInc);
}else{
// Flips the display orientation 0 degrees
send_cmd1(SegRemap | 0x1);
send_cmd1(ComScanDec);
}
send_cmd2(SetComPins, 0x2);
send_cmd2(SetContrast, 0x8f);
send_cmd2(SetPreCharge, 0xf1);
send_cmd2(SetVComDetect, 0x40);
send_cmd1(DisplayAllOnResume);
send_cmd1(NormalDisplay);
send_cmd1(DeActivateScroll);
send_cmd1(DisplayOn);
send_cmd2(SetContrast, 0); // Dim
clear_display();
success = true;
iota_gfx_flush();
#if DEBUG_TO_SCREEN
print_set_sendchar(capture_sendchar);
#endif
done:
return success;
}
bool iota_gfx_off(void) {
bool success = false;
send_cmd1(DisplayOff);
success = true;
done:
return success;
}
bool iota_gfx_on(void) {
bool success = false;
send_cmd1(DisplayOn);
success = true;
done:
return success;
}
void matrix_write_char_inner(struct CharacterMatrix *matrix, uint8_t c) {
*matrix->cursor = c;
++matrix->cursor;
if (matrix->cursor - &matrix->display[0][0] == sizeof(matrix->display)) {
// We went off the end; scroll the display upwards by one line
memmove(&matrix->display[0], &matrix->display[1],
MatrixCols * (MatrixRows - 1));
matrix->cursor = &matrix->display[MatrixRows - 1][0];
memset(matrix->cursor, ' ', MatrixCols);
}
}
void matrix_write_char(struct CharacterMatrix *matrix, uint8_t c) {
matrix->dirty = true;
if (c == '\n') {
// Clear to end of line from the cursor and then move to the
// start of the next line
uint8_t cursor_col = (matrix->cursor - &matrix->display[0][0]) % MatrixCols;
while (cursor_col++ < MatrixCols) {
matrix_write_char_inner(matrix, ' ');
}
return;
}
matrix_write_char_inner(matrix, c);
}
void iota_gfx_write_char(uint8_t c) {
matrix_write_char(&display, c);
}
void matrix_write(struct CharacterMatrix *matrix, const char *data) {
const char *end = data + strlen(data);
while (data < end) {
matrix_write_char(matrix, *data);
++data;
}
}
void matrix_write_ln(struct CharacterMatrix *matrix, const char *data) {
char data_ln[strlen(data)+2];
snprintf(data_ln, sizeof(data_ln), "%s\n", data);
matrix_write(matrix, data_ln);
}
void iota_gfx_write(const char *data) {
matrix_write(&display, data);
}
void matrix_write_P(struct CharacterMatrix *matrix, const char *data) {
while (true) {
uint8_t c = pgm_read_byte(data);
if (c == 0) {
return;
}
matrix_write_char(matrix, c);
++data;
}
}
void iota_gfx_write_P(const char *data) {
matrix_write_P(&display, data);
}
void matrix_clear(struct CharacterMatrix *matrix) {
memset(matrix->display, ' ', sizeof(matrix->display));
matrix->cursor = &matrix->display[0][0];
matrix->dirty = true;
}
void iota_gfx_clear_screen(void) {
matrix_clear(&display);
}
void matrix_render(struct CharacterMatrix *matrix) {
last_flush = timer_read();
iota_gfx_on();
#if DEBUG_TO_SCREEN
++displaying;
#endif
// Move to the home position
send_cmd3(PageAddr, 0, MatrixRows - 1);
send_cmd3(ColumnAddr, 0, (MatrixCols * FontWidth) - 1);
if (i2c_start_write(SSD1306_ADDRESS)) {
goto done;
}
if (i2c_master_write(0x40)) {
// Data mode
goto done;
}
for (uint8_t row = 0; row < MatrixRows; ++row) {
for (uint8_t col = 0; col < MatrixCols; ++col) {
const uint8_t *glyph = font + (matrix->display[row][col] * FontWidth);
for (uint8_t glyphCol = 0; glyphCol < FontWidth; ++glyphCol) {
uint8_t colBits = pgm_read_byte(glyph + glyphCol);
i2c_master_write(colBits);
}
// 1 column of space between chars (it's not included in the glyph)
//i2c_master_write(0);
}
}
matrix->dirty = false;
done:
i2c_master_stop();
#if DEBUG_TO_SCREEN
--displaying;
#endif
}
void iota_gfx_flush(void) {
matrix_render(&display);
}
__attribute__ ((weak))
void iota_gfx_task_user(void) {
}
void iota_gfx_task(void) {
iota_gfx_task_user();
if (display.dirty|| force_dirty) {
iota_gfx_flush();
force_dirty = false;
}
if (timer_elapsed(last_flush) > ScreenOffInterval) {
iota_gfx_off();
}
}
bool process_record_gfx(uint16_t keycode, keyrecord_t *record) {
force_dirty = true;
return true;
}
#endif

View File

@ -0,0 +1,91 @@
#pragma once
#include <stdbool.h>
#include <stdio.h>
#include "pincontrol.h"
#include "action.h"
enum ssd1306_cmds {
DisplayOff = 0xAE,
DisplayOn = 0xAF,
SetContrast = 0x81,
DisplayAllOnResume = 0xA4,
DisplayAllOn = 0xA5,
NormalDisplay = 0xA6,
InvertDisplay = 0xA7,
SetDisplayOffset = 0xD3,
SetComPins = 0xda,
SetVComDetect = 0xdb,
SetDisplayClockDiv = 0xD5,
SetPreCharge = 0xd9,
SetMultiPlex = 0xa8,
SetLowColumn = 0x00,
SetHighColumn = 0x10,
SetStartLine = 0x40,
SetMemoryMode = 0x20,
ColumnAddr = 0x21,
PageAddr = 0x22,
ComScanInc = 0xc0,
ComScanDec = 0xc8,
SegRemap = 0xa0,
SetChargePump = 0x8d,
ExternalVcc = 0x01,
SwitchCapVcc = 0x02,
ActivateScroll = 0x2f,
DeActivateScroll = 0x2e,
SetVerticalScrollArea = 0xa3,
RightHorizontalScroll = 0x26,
LeftHorizontalScroll = 0x27,
VerticalAndRightHorizontalScroll = 0x29,
VerticalAndLeftHorizontalScroll = 0x2a,
};
// Controls the SSD1306 128x32 OLED display via i2c
#ifndef SSD1306_ADDRESS
#define SSD1306_ADDRESS 0x3C
#endif
#define DisplayHeight 32
#define DisplayWidth 128
#define FontHeight 8
#define FontWidth 6
#define MatrixRows (DisplayHeight / FontHeight)
#define MatrixCols (DisplayWidth / FontWidth)
struct CharacterMatrix {
uint8_t display[MatrixRows][MatrixCols];
uint8_t *cursor;
bool dirty;
};
struct CharacterMatrix display;
bool iota_gfx_init(bool rotate);
void iota_gfx_task(void);
bool iota_gfx_off(void);
bool iota_gfx_on(void);
void iota_gfx_flush(void);
void iota_gfx_write_char(uint8_t c);
void iota_gfx_write(const char *data);
void iota_gfx_write_P(const char *data);
void iota_gfx_clear_screen(void);
void iota_gfx_task_user(void);
void matrix_clear(struct CharacterMatrix *matrix);
void matrix_write_char_inner(struct CharacterMatrix *matrix, uint8_t c);
void matrix_write_char(struct CharacterMatrix *matrix, uint8_t c);
void matrix_write(struct CharacterMatrix *matrix, const char *data);
void matrix_write_ln(struct CharacterMatrix *matrix, const char *data);
void matrix_write_P(struct CharacterMatrix *matrix, const char *data);
void matrix_render(struct CharacterMatrix *matrix);
bool process_record_gfx(uint16_t keycode, keyrecord_t *record);