deskthority

Code: Select all

#define BACKLIGHT_OFF 2
#define BACKLIGHT_ON 3
#define BACKLIGHT_INCREASE 4
#define BACKLIGHT_DECREASE 5

void decrease(void);
void increase(void);
void turn_off();
void turn_on(void);
void set_pwm_value(void);
void init_pwm(void);

Code: Select all

#include "keymap_common.h"
#include <avr/io.h>
#include "backlight.h"
#include <stdlib.h>
#include <time.h>

const int step = 205;
int pwm_cycle = 0; //full cycle is reached at 2047

int is_init = 0;

const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
	KEYMAP(ESC,  1,    2,    3,   4,   5,   6,   7,    8,    9,    0, MINS,   EQL, BSPC,   INS, HOME, \
           TAB,  Q,    W,    E,   R,   T,   Y,   U,    I,    O,    P, LBRC,  RBRC, BSLASH,   DEL, END,  \
           CAPS, A,    S,    D,   F,   G,   H,   J,    K,    L, SCLN, QUOT,         ENT,              \
           LSFT,    Z,    X,    C,   V,   B,   N,   M, COMM,  DOT, SLSH,           RSFT,    UP,        \
           LCTL, LGUI, LALT,         SPC,                    RALT,  FN0,     RCTL,  LEFT, DOWN, RIGHT),
	
	/* 1: FN 1 */
    KEYMAP(GRAVE,   F1,   F2,   F3,   F4,   F5,   F6,   F7,   F8,   F9,   F10,   F11,   F12, TRNS, MEDIA_PLAY_PAUSE, PGUP, 				\
            TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,  PSCR,  SLCK, PAUSE, FN1,       MEDIA_STOP, PGDN,				\
            TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,  TRNS,  TRNS,        TRNS,                                   	\
            LSFT, TRNS, TRNS, CALC, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,  TRNS,               RSFT,             VOLU,            		\
            LCTL, APP, LALT,             TRNS,             RALT, TRNS,         RCTL,         MEDIA_PREV_TRACK, VOLD, MEDIA_NEXT_TRACK),
	
	/* 2: FN 2 */
    KEYMAP(GRAVE,   F1,   F2,   F3,   F4,   F5,   F6,   F7,   F8,   F9,   F10,   F11,   F12, TRNS, MEDIA_PLAY_PAUSE, PGUP, 				\
            TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,  PSCR,  SLCK, PAUSE, TRNS,       MEDIA_STOP, PGDN,				\
            TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,  TRNS,  TRNS,        TRNS,                                   	\
            LSFT, TRNS, TRNS, CALC, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,  TRNS,               RSFT,             FN4,            		\
            LCTL, APP, LALT,             TRNS,             RALT, TRNS,         RCTL,          FN2,             FN5, FN3),

};

const action_t PROGMEM fn_actions[] = {
	[0] = ACTION_LAYER_MOMENTARY(1),
	[1] = ACTION_LAYER_MOMENTARY(2),
	[2] = ACTION_FUNCTION_TAP(BACKLIGHT_OFF),
	[3] = ACTION_FUNCTION_TAP(BACKLIGHT_ON),
	[4] = ACTION_FUNCTION_TAP(BACKLIGHT_INCREASE),
	[5] = ACTION_FUNCTION_TAP(BACKLIGHT_DECREASE),
};

int min(int a, int b)
{
	if (a <= b){return a;}
	else{return b;}
}

int max(int a, int b)
{
	if (a >= b){return a;}
	else{return b;}
}

void init_pwm()
{
	DDRD |= (1 << 7);
	TCCR4B = 0x01;
	TCCR4C = 0x09;
	TCCR4D = 0x00;
	TCCR4E = 0x40;
	TC4H = 7; 
	OCR4C = 0xFF;	
	is_init = 1;
}

void turn_off()
{	
	pwm_cycle = 0;
	set_pwm_value();
}

void turn_on()
{	
	pwm_cycle = 2047;
	set_pwm_value();
}

void set_pwm_value()
{	
	if(!is_init)
	{
		init_pwm();
	}
	pwm_cycle = min(max(0, pwm_cycle),2047);
	pwm_cycle &= 0x7FF;  // restrict to 11 bits
	TC4H = (pwm_cycle >> 8);
	OCR4D = pwm_cycle & 0x00FF;
}

void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
{
	switch (id)
	{
		case BACKLIGHT_OFF:
			turn_off(0);			
			break;
		case BACKLIGHT_ON:			
			turn_on();						
			break;
		case BACKLIGHT_INCREASE:
			increase();
			break;
		case BACKLIGHT_DECREASE:
			decrease();
			break;
		default:
			turn_off(0);
			break;
	}
}

void increase()
{
	pwm_cycle = pwm_cycle + step;
	set_pwm_value();
}

void decrease()
{
	pwm_cycle = pwm_cycle - step;
	set_pwm_value();
}

Code: Select all

#ifndef SATAN_H
#define SATAN_H

#include "matrix.h"
#include "keymap_common.h"
#include "backlight.h"
#include "rgblight.h"
#include <stddef.h>

// This a shortcut to help you visually see your layout.
// The following is an example using the Planck MIT layout
// The first section contains all of the arguements
// The second converts the arguments into a two-dimensional array
#define KEYMAP( \
	k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, k0c, k0d, \
	k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b, k1c, k1d, \
	k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b, k2c,      \
	k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b,      k3d, \
	k40,      k42,                k46,                     k4b,      k4d\
) \
{ \
		{k00, k01, k02, k03, 	k04, 	k05, k06, 	k07, 	k08, 	k09, 	k0a, 	k0b, 	k0c, 	k0d}, \
		{k10, k11, k12, k13, 	k14, 	k15, k16, 	k17, 	k18, 	k19, 	k1a, 	k1b, 	k1c, 	k1d}, \
		{k20, k21, k22, k23, 	k24, 	k25, k26, 	k27, 	k28, 	k29, 	k2a, 	k2b, 	k2c, 	KC_NO}, \
		{k30, k31, k32, k33, 	k34, 	k35, k36, 	k37, 	k38, 	k39, 	k3a, 	k3b, 	KC_NO, 	k3d}, \
		{k40, KC_NO, k42, KC_NO, KC_NO, KC_NO, k46, KC_NO, KC_NO, KC_NO,  KC_NO,      k4b, 	KC_NO, 	k4d}  \
}

void * matrix_init_user(void);
void * matrix_scan_user(void);

#endif



//#define KEYMAP( \
//	k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, k0c, k0d, \
//	k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b, k1c, k1d, \
//	k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b, k2c,      \
//	k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b,      k3d, \
//	k40,      k42,                k46,                     k4b,      k4d \
//) \
//{ \
//		{k00, k01, k02, k03, 	k04, 	k05, k06, 	k07, 	k08, 	k09, 	k0a, 	k0b, k0c, 	k0d}, \
//		{k10, k11, k12, k13, 	k14, 	k15, k16, 	k17, 	k18, 	k19, 	k1a, 	k1b, k1c, 	k1d}, \
//		{k20, k21, k22, k23, 	k24, 	k25, k26, 	k27, 	k28, 	k29, 	k2a, 	k2b, k2c, KC_NO}, \
//		{k30, k31, k32, k33, 	k34, 	k35, k36, 	k37, 	k38, 	k39, 	k3a, 	k3b, KC_NO, 	k3d}, \
//		{k40, KC_NO, k42, KC_NO, KC_NO,	KC_NO, 	k46, KC_NO, KC_NO, KC_NO,	KC_NO, 	k4b, 	KC_NO, 	k4d}  \
//}

Code: Select all

// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
// this is the style you want to emulate.

#include "satan.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.
#define _BW 0
#define _FL 1
// #define _MV 3

const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  /* Keymap _BW: (Base Windows) Windows Default Layer
   * ,-----------------------------------------------------------.
   * |Esc~| 1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =|Backsp|Backsp (!!!NOTE!!! THE RIGHT MOST BUTTON ON THE SPLIT BS IS k49 on the grid (satan.h)!!|
   * |-----------------------------------------------------------|
   * |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]|    \|
   * |-----------------------------------------------------------|
   * |CAPS/FL|  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '|Return |
   * |-----------------------------------------------------------|
   * |Shift|shift   |  Z|  X|  C|  V|  B|  N|  M|  ,|  .|  /|Shift  |Backlight step|
   * |-----------------------------------------------------------|
   * |Ctrl|Gui |Alt |      Space            |Alt |FN  |CTRL      |
   * `-----------------------------------------------------------'
   *
*/
[_BW] = KEYMAP(
  F(0),    KC_1,    KC_2,   KC_3,   KC_4,   KC_5,   KC_6,   KC_7,   KC_8,   KC_9,    KC_0,     KC_MINS,  KC_EQL,   KC_BSPC, \
  KC_TAB,  KC_Q,    KC_W,   KC_E,   KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,    KC_P,     KC_LBRC,  KC_RBRC,  KC_ENT, \
  KC_TRNS, KC_A,    KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,    KC_SCLN,  KC_QUOT,  KC_BSLS, \
  KC_LSFT, KC_LSFT, KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,   KC_SLSH,  KC_RSFT, \
  KC_LCTL,          KC_LALT,                KC_SPC,                                                      KC_RALT,  MO(1) ),

  /* Keymap _FL: Function Layer
   * ,-----------------------------------------------------------.
   * |  `| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Delete |
   * |-----------------------------------------------------------|
   * |  |  |Up | f(1)|f(2)|f(3)|f(4)|f(5)|f(6)|f(7)|f(8)|BL_DEC|BL_INC|BL_TOGG|
   * |-----------------------------------------------------------|
   * |  |Lef|Dow|Rig|   |   |   |   |  |     |home| pgup|BL_STEP |
   * |-----------------------------------------------------------|
   * |   |    |    |  |  |  |  |   |   |   | end| pgdn |     |   |
   * |-----------------------------------------------------------|
   * |    |    |    |                              |     |   |   |
   * `-----------------------------------------------------------'
   */
 [_FL] = KEYMAP(
   KC_GRV,  KC_F1,   KC_F2,     KC_F3,    KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,     KC_F10,    KC_F11,    KC_F12,    KC_DEL,  \
   KC_TRNS, KC_TRNS, KC_UP,     F(1),     F(2),    F(3),    F(4),    F(5),    F(6),    F(7),      F(8),      BL_DEC,    BL_INC,    BL_TOGG, \
   KC_TRNS, KC_LEFT, KC_DOWN,   KC_RGHT,  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,   KC_HOME,   KC_PGUP,   BL_STEP, \
   KC_TRNS, KC_TRNS, KC_TRNS,   KC_TRNS,  KC_TRNS, KC_TRNS, KC_TRNS, KC_VOLD, KC_VOLU, KC_MUTE,   KC_END,    KC_PGDN,     KC_TRNS, \
   KC_TRNS,          KC_TRNS,          KC_TRNS,                                                              KC_TRNS,      KC_TRNS),
 
};


enum function_id {
    SHIFT_ESC,
    RGBLED_TOGGLE,
    RGBLED_STEP_MODE,
    RGBLED_INCREASE_HUE,
    RGBLED_DECREASE_HUE,
    RGBLED_INCREASE_SAT,
    RGBLED_DECREASE_SAT,
    RGBLED_INCREASE_VAL,
    RGBLED_DECREASE_VAL,
};

const uint16_t PROGMEM fn_actions[] = {
  [0]  = ACTION_FUNCTION(SHIFT_ESC),
  [1]  = ACTION_FUNCTION(RGBLED_TOGGLE),
  [2]  = ACTION_FUNCTION(RGBLED_STEP_MODE),
  [3]  = ACTION_FUNCTION(RGBLED_INCREASE_HUE),
  [4]  = ACTION_FUNCTION(RGBLED_DECREASE_HUE),
  [5]  = ACTION_FUNCTION(RGBLED_INCREASE_SAT),
  [6]  = ACTION_FUNCTION(RGBLED_DECREASE_SAT),
  [7]  = ACTION_FUNCTION(RGBLED_INCREASE_VAL),
  [8]  = ACTION_FUNCTION(RGBLED_DECREASE_VAL),
//  [9]  = ACTION_LAYER_ON(_FL, ON_PRESS),
//  [10] = ACTION_LAYER_OFF(_FL, ON_PRESS),
//  [11] = ACTION_LAYER_TAP_KEY(_FL, KC_CAPS),
};

#define MODS_CTRL_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
  static uint8_t shift_esc_shift_mask;
  switch (id) {
    case SHIFT_ESC:
      shift_esc_shift_mask = get_mods()&MODS_CTRL_MASK;
      if (record->event.pressed) {
        if (shift_esc_shift_mask) {
          add_key(KC_GRV);
          send_keyboard_report();
        } else {
          add_key(KC_ESC);
          send_keyboard_report();
        }
      } else {
        if (shift_esc_shift_mask) {
          del_key(KC_GRV);
          send_keyboard_report();
        } else {
          del_key(KC_ESC);
          send_keyboard_report();
        }
      }
      break;
    case RGBLED_TOGGLE:
      //led operations
      if (record->event.pressed) {
        rgblight_toggle();
      }

      break;
    case RGBLED_INCREASE_HUE:
      if (record->event.pressed) {
        rgblight_increase_hue();
      }
      break;
    case RGBLED_DECREASE_HUE:
      if (record->event.pressed) {
        rgblight_decrease_hue();
      }
      break;
    case RGBLED_INCREASE_SAT:
      if (record->event.pressed) {
        rgblight_increase_sat();
      }
      break;
    case RGBLED_DECREASE_SAT:
      if (record->event.pressed) {
        rgblight_decrease_sat();
      }
      break;
      case RGBLED_INCREASE_VAL:
        if (record->event.pressed) {
          rgblight_increase_val();
        }
        break;
      case RGBLED_DECREASE_VAL:
        if (record->event.pressed) {
          rgblight_decrease_val();
        }
        break;
      case RGBLED_STEP_MODE:
        if (record->event.pressed) {
          rgblight_step();
        }
        break;
  }
}


const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
{
  // MACRODOWN only works in this function
      switch(id) {
        case 0:
          return (record->event.pressed ? MACRO( D(LSFT) ,T(H) , U(LSFT), T(E), T(L), T(L), T(O), END ) :MACRO( END ));
          break;
        case 1:
          return (record->event.pressed ? MACRO(D(LSFT),T(A),T(S),T(D),U(LSFT),T(F),T(G),T(H), END ) :MACRO( END ));
          break;
      }
    return MACRO_NONE;
};

Code: Select all

diff --git a/tmk_core/common/host.c b/tmk_core/common/host.c
index e9b7916..e1fa52d 100644
--- a/tmk_core/common/host.c
+++ b/tmk_core/common/host.c
@@ -54,7 +54,7 @@ void host_keyboard_send(report_keyboard_t *report)
     (*driver->send_keyboard)(report);
 
     if (debug_keyboard) {
-        dprint("keyboard_report: ");
+        dprint("keyboard: ");
         for (uint8_t i = 0; i < KEYBOARD_REPORT_SIZE; i++) {
             dprintf("%02X ", report->raw[i]);
         }
@@ -75,6 +75,10 @@ void host_system_send(uint16_t report)
 
     if (!driver) return;
     (*driver->send_system)(report);
+
+    if (debug_keyboard) {
+        dprintf("system: %04X\n", report);
+    }
 }
 
 void host_consumer_send(uint16_t report)
@@ -84,6 +88,10 @@ void host_consumer_send(uint16_t report)
 
     if (!driver) return;
     (*driver->send_consumer)(report);
+
+    if (debug_keyboard) {
+        dprintf("consumer: %04X\n", report);
+    }
 }
 
 uint16_t host_last_sysytem_report(void)

Code: Select all

#define KEYMAP( \
    K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \
    K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C,      \
    K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D, \
    K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D, \
    K40, K41, K42,           K45,                     K4A, K4B, K4C, K4D  \
) { \
    { KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07, KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D }, \
    { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17, KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_NO    }, \
    { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27, KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D }, \
    { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37, KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D }, \
    { KC_##K40, KC_##K41, KC_##K42, KC_NO,    KC_NO,    KC_##K45, KC_NO,    KC_NO,    KC_NO,    KC_NO,    KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D }  \
}

Code: Select all

inline
matrix_row_t matrix_get_row(uint8_t row)
{
    return matrix[row];
}

/* Column pin configuration
 * col: 0   1   2   3   4   5   6   7   8   9   10  11  12  13
 * pin: F0  F1  E6  C7  C6  B6  D4  B1  B7  B5  B4  D7  D6  B3  (Rev.C)
 */
static void  init_cols(void)
{
    // Input with pull-up(DDR:0, PORT:1)
    DDRF  &= ~(1<<0 | 1<<1);
    PORTF |=  (1<<0 | 1<<1);
    DDRE  &= ~(1<<6);
    PORTE |=  (1<<6);
    DDRD  &= ~(1<<7 | 1<<6 | 1<<4);
    PORTD |=  (1<<7 | 1<<6 | 1<<4);
    DDRC  &= ~(1<<7 | 1<<6);
    PORTC |=  (1<<7 | 1<<6);
    DDRB  &= ~(1<<7 | 1<<6 | 1<< 5 | 1<<4 | 1<<3 | 1<<1);
    PORTB |=  (1<<7 | 1<<6 | 1<< 5 | 1<<4 | 1<<3 | 1<<1);
}

static matrix_row_t read_cols(void)
{
    return (PINF&(1<<0) ? 0 : (1<<0)) |
           (PINF&(1<<1) ? 0 : (1<<1)) |
           (PINE&(1<<6) ? 0 : (1<<2)) |
           (PINC&(1<<7) ? 0 : (1<<3)) |
           (PINC&(1<<6) ? 0 : (1<<4)) |
           (PINB&(1<<6) ? 0 : (1<<5)) |
           (PIND&(1<<4) ? 0 : (1<<6)) |
           (PINB&(1<<1) ? 0 : (1<<7)) |
           (PINB&(1<<7) ? 0 : (1<<8)) |     // Rev.C
           (PINB&(1<<5) ? 0 : (1<<9)) |
           (PINB&(1<<4) ? 0 : (1<<10)) |
           (PIND&(1<<7) ? 0 : (1<<11)) |
           (PIND&(1<<6) ? 0 : (1<<12)) |
           (PINB&(1<<3) ? 0 : (1<<13));
}

Code: Select all

const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    /* 0: qwerty */
    KEYMAP(
    	ESC, 1,   2,   3,   4,   5,   6,   7,   8,   9,   0,   MINS,EQL, BSPC,  \
        TAB, Q,   W,   E,   R,   T,   Y,   U,   I,   O,   P,   LBRC,RBRC,       \
        CAPS,A,   S,   D,   F,   G,   H,   J,   K,   L,   SCLN,QUOT,NUHS,  ENT, \
        LSFT,NUBS,  Z,   X,   C,   V,   B,   N,   M,   COMM,DOT, SLSH,RSFT, FN0,\
        LCTL,LGUI,LALT,          SPC,                     RALT,RGUI,APP, RCTL),
    /* 1: fn layer */
    KEYMAP(
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,      \
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \
        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \
        TRNS,TRNS,TRNS,          TRNS,                     TRNS,TRNS,TRNS,TRNS),
};
const action_t PROGMEM fn_actions[] = {
    [0] = ACTION_LAYER_MOMENTARY(1),
};