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
2018-12-31 01:34:06 +09:00 · 2018-12-31 01:34:06 +09:00 · 46b4b4407f
commit 46b4b4407f
parent c2390bf321
24 changed files with 1918 additions and 342 deletions
--- a/keyboards/comet46/comet46.c
+++ b/keyboards/comet46/comet46.c
@ -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) {
--- a/keyboards/comet46/comet46.h
+++ b/keyboards/comet46/comet46.h
@ -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
--- a/keyboards/comet46/config.h
+++ b/keyboards/comet46/config.h
@ -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
--- a/keyboards/comet46/i2c.c
+++ b/keyboards/comet46/i2c.c
@ -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
--- a/keyboards/comet46/i2c.h
+++ b/keyboards/comet46/i2c.h
@ -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
--- a/keyboards/comet46/keymaps/default-rgbled/keymap.c
+++ b/keyboards/comet46/keymaps/default-rgbled/keymap.c
@ -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;
+}
--- a/keyboards/comet46/keymaps/default-rgbled/readme.md
+++ b/keyboards/comet46/keymaps/default-rgbled/readme.md
@ -0,0 +1,3 @@
+## default-led
+
+A keymap that is compatible with mitosis-type receivers, which use RGB LED for layer indication.
--- a/keyboards/comet46/keymaps/default/config.h
+++ b/keyboards/comet46/keymaps/default/config.h
@ -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
--- a/keyboards/comet46/keymaps/default/keymap.c
+++ b/keyboards/comet46/keymaps/default/keymap.c
@ -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;
 }
--- a/keyboards/comet46/keymaps/default/readme.md
+++ b/keyboards/comet46/keymaps/default/readme.md
@ -0,0 +1,3 @@
+## default-oled-display
+
+A keymap that is compatible with receivers with an OLED display.
--- a/keyboards/comet46/keymaps/default/rules.mk
+++ b/keyboards/comet46/keymaps/default/rules.mk
@ -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
--- a/keyboards/comet46/keymaps/satt/action_pseudo_lut.c
+++ b/keyboards/comet46/keymaps/satt/action_pseudo_lut.c
@ -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);
+  }
 }
--- a/keyboards/comet46/keymaps/satt/config.h
+++ b/keyboards/comet46/keymaps/satt/config.h
@ -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
--- a/keyboards/comet46/keymaps/satt/keymap.c
+++ b/keyboards/comet46/keymaps/satt/keymap.c
@ -4,45 +4,77 @@
 #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_XXXX KC_NO
@ -51,11 +83,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

  [_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
  //                    +----+----+---/       \---+----+----+
@ -79,7 +111,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  //|----+----+----+----+----+----+----+     +----+----+----+----+----+----+----|
         ,    ,    ,    ,    ,    ,    ,      XXXX,LEFT,DOWN, UP ,RGHT,END ,    ,
  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
-         ,    ,    ,    ,    ,    ,    ,      HOME,XXXX,XXXX,XXXX,XXXX,XXXX,    ,
+         ,    ,    ,    ,    ,    ,    ,      HOME,XXXX,PGDN,PGUP,XXXX,XXXX,    ,
  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
                             ,    ,    ,          ,    ,
  //                    +----+----+---/       \---+----+----+
@ -87,11 +119,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

  [_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
  //                    +----+----+---/       \---+----+----+
@ -100,11 +132,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

  [_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,    ,
  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
                             ,    ,    ,          ,    ,
  //                    +----+----+---/       \---+----+----+
@ -114,9 +146,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  //,----+----+----+----+----+----+               +----+----+----+----+----+----.
         , 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,    ,
  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
                             ,    ,    ,          ,    ,
  //                    +----+----+---/       \---+----+----+
@ -136,62 +168,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

 };

-
-/*
- * 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:
      return update_tri_layer_state(state, _PSEUDO_US_RAISE, _PSEUDO_US_LOWER, _ADJUST);
      break;
@ -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;
--- a/keyboards/comet46/keymaps/satt/keymap_jis2us.h
+++ b/keyboards/comet46/keymaps/satt/keymap_jis2us.h
@ -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
--- a/keyboards/comet46/keymaps/satt/rules.mk
+++ b/keyboards/comet46/keymaps/satt/rules.mk
@ -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
--- a/keyboards/comet46/lib/glcdfont.c
+++ b/keyboards/comet46/lib/glcdfont.c
@ -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
--- a/keyboards/comet46/lib/host_led_state_reader.c
+++ b/keyboards/comet46/lib/host_led_state_reader.c
@ -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;
+}
--- a/keyboards/comet46/lib/keylogger.c
+++ b/keyboards/comet46/lib/keylogger.c
@ -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;
+}
--- a/keyboards/comet46/lib/modifier_state_reader.c
+++ b/keyboards/comet46/lib/modifier_state_reader.c
@ -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;
+}
--- a/keyboards/comet46/readme.md
+++ b/keyboards/comet46/readme.md
@ -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.
+
--- a/keyboards/comet46/rules.mk
+++ b/keyboards/comet46/rules.mk
@ -1,11 +1,7 @@
-
-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
@ -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
--- a/keyboards/comet46/ssd1306.c
+++ b/keyboards/comet46/ssd1306.c
@ -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
--- a/keyboards/comet46/ssd1306.h
+++ b/keyboards/comet46/ssd1306.h
@ -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);