keyboards/rama/m6_a/keymaps/default/keymap.c

   1 #include QMK_KEYBOARD_H
   2
   3 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   4
   5     LAYOUT(
   6         TO(1), KC_A, KC_B, KC_C, KC_D, KC_E),
   7
   8     LAYOUT(
   9         TO(2), KC_F, KC_G, KC_H, KC_I, KC_J),
  10
  11     LAYOUT(
  12         TO(3), KC_K, KC_L, KC_M, KC_N, KC_O),
  13
  14     LAYOUT(
  15         TO(4), KC_P, KC_Q, KC_R, KC_S, KC_T),
  16
  17     LAYOUT(
  18         TO(5), KC_U, KC_V, KC_W, KC_X, KC_Y),
  19
  20     LAYOUT(
  21         TO(0), KC_Z, KC_1, KC_2, KC_3, KC_4)};
  22
  23 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
  24 {
  25     //keyevent_t event = record->event;
  26
  27     switch (id)
  28     {
  29     case 0:
  30         if (record->event.pressed)
  31         {
  32             return MACRO(T(T), T(G), T(L), T(H), T(F), T(ENT), END);
  33         }
  34         break;
  35     case 1:
  36         if (record->event.pressed)
  37         {
  38             return MACRO(T(T), T(G), T(G), T(ENT), END);
  39         }
  40         break;
  41     case 2:
  42         if (record->event.pressed)
  43         {
  44             return MACRO(D(NO), T(L), U(NO), END);
  45         }
  46         break;
  47     case 3:
  48         if (record->event.pressed)
  49         {
  50             return MACRO(D(LCTL), T(Z), U(LCTL), END);
  51         }
  52         break;
  53     case 4:
  54         if (record->event.pressed)
  55         {
  56             return MACRO(D(LCTL), D(LSFT), T(Z), U(LSFT), U(LCTL), END);
  57         }
  58         break;
  59     case 5:
  60         if (record->event.pressed)
  61         {
  62             return MACRO(D(LCTL), T(X), U(LCTL), END);
  63         }
  64         break;
  65     case 6:
  66         if (record->event.pressed)
  67         {
  68             return MACRO(D(LCTL), T(C), U(LCTL), END);
  69         }
  70         break;
  71     case 7:
  72         if (record->event.pressed)
  73         {
  74             return MACRO(D(LCTL), T(V), U(LCTL), END);
  75         }
  76         break;
  77     }
  78     return MACRO_NONE;
  79 }
  80
  81 // M6-A LEDs are connected to D6, B6, F5, B4, C7, F7
  82 // This is 1-based because I copied it from Knops code.
  83 void set_switch_led(int ledId, bool state)
  84 {
  85     if (state)
  86     {
  87         switch (ledId)
  88         {
  89         case 1:
  90             PORTD |= (1 << 6);
  91             break;
  92         case 2:
  93             PORTB |= (1 << 6);
  94             break;
  95         case 3:
  96             PORTF |= (1 << 5);
  97             break;
  98         case 4:
  99             PORTB |= (1 << 4);
 100             break;
 101         case 5:
 102             PORTC |= (1 << 7);
 103             break;
 104         case 6:
 105             PORTF |= (1 << 7);
 106             break;
 107         }
 108     }
 109     else
 110     {
 111         switch (ledId)
 112         {
 113         case 1:
 114             PORTD &= ~(1 << 6);
 115             break;
 116         case 2:
 117             PORTB &= ~(1 << 6);
 118             break;
 119         case 3:
 120             PORTF &= ~(1 << 5);
 121             break;
 122         case 4:
 123             PORTB &= ~(1 << 4);
 124             break;
 125         case 5:
 126             PORTC &= ~(1 << 7);
 127             break;
 128         case 6:
 129             PORTF &= ~(1 << 7);
 130             break;
 131         }
 132     }
 133 }
 134
 135 void set_layer_led(int layerId)
 136 {
 137     // UNUSED
 138 }
 139
 140 void led_set_layer(int layer);
 141
 142 void matrix_init_user(void)
 143 {
 144     led_init_ports();
 145     led_set_layer(0);
 146 }
 147
 148 void matrix_scan_user(void)
 149 {
 150 }
 151
 152 // M6-A LEDs are connected to D6, B6, F5, B4, C7, F7
 153 void led_init_ports()
 154 {
 155     // Switch #1
 156     DDRD |= (1 << 6);
 157     PORTD &= ~(1 << 6);
 158
 159     // Switch #2
 160     DDRB |= (1 << 6);
 161     PORTB &= ~(1 << 6);
 162
 163     // Switch #3
 164     DDRF |= (1 << 5);
 165     PORTF &= ~(1 << 5);
 166
 167     // Switch #4
 168     DDRB |= (1 << 4);
 169     PORTB &= ~(1 << 4);
 170
 171     // Switch #5
 172     DDRC |= (1 << 7);
 173     PORTC &= ~(1 << 7);
 174
 175     // Switch #6
 176     DDRF |= (1 << 7);
 177     PORTF &= ~(1 << 7);
 178 }
 179
 180 void led_set_user(uint8_t usb_led)
 181 {
 182
 183     if (usb_led & (1 << USB_LED_NUM_LOCK))
 184     {
 185     }
 186     else
 187     {
 188     }
 189
 190     if (usb_led & (1 << USB_LED_CAPS_LOCK))
 191     {
 192     }
 193     else
 194     {
 195     }
 196
 197     if (usb_led & (1 << USB_LED_SCROLL_LOCK))
 198     {
 199     }
 200     else
 201     {
 202     }
 203
 204     if (usb_led & (1 << USB_LED_COMPOSE))
 205     {
 206     }
 207     else
 208     {
 209     }
 210
 211     if (usb_led & (1 << USB_LED_KANA))
 212     {
 213     }
 214     else
 215     {
 216     }
 217 }
 218
 219 void led_set_layer(int layer)
 220 {
 221     switch (layer)
 222     {
 223     case 0:
 224         set_switch_led(1, true);
 225         set_switch_led(2, false);
 226         set_switch_led(3, false);
 227         set_switch_led(4, false);
 228         set_switch_led(5, false);
 229         set_switch_led(6, false);
 230         break;
 231     case 1:
 232         set_switch_led(1, false);
 233         set_switch_led(2, true);
 234         set_switch_led(3, false);
 235         set_switch_led(4, false);
 236         set_switch_led(5, false);
 237         set_switch_led(6, false);
 238         break;
 239     case 2:
 240         set_switch_led(1, false);
 241         set_switch_led(2, false);
 242         set_switch_led(3, true);
 243         set_switch_led(4, false);
 244         set_switch_led(5, false);
 245         set_switch_led(6, false);
 246         break;
 247     case 3:
 248         set_switch_led(1, false);
 249         set_switch_led(2, false);
 250         set_switch_led(3, false);
 251         set_switch_led(4, true);
 252         set_switch_led(5, false);
 253         set_switch_led(6, false);
 254         break;
 255     case 4:
 256         set_switch_led(1, false);
 257         set_switch_led(2, false);
 258         set_switch_led(3, false);
 259         set_switch_led(4, false);
 260         set_switch_led(5, true);
 261         set_switch_led(6, false);
 262         break;
 263     case 5:
 264         set_switch_led(1, false);
 265         set_switch_led(2, false);
 266         set_switch_led(3, false);
 267         set_switch_led(4, false);
 268         set_switch_led(5, false);
 269         set_switch_led(6, true);
 270         break;
 271     default:
 272         set_switch_led(1, true);
 273         set_switch_led(2, true);
 274         set_switch_led(3, true);
 275         set_switch_led(4, true);
 276         set_switch_led(5, true);
 277         set_switch_led(6, true);
 278         break;
 279     }
 280 }
 281
 282 bool process_record_user(uint16_t keycode, keyrecord_t *record)
 283 {
 284     switch (keycode)
 285     {
 286     case TO(0):
 287         if (record->event.pressed)
 288         {
 289             led_set_layer(0);
 290         }
 291         break;
 292     case TO(1):
 293         if (record->event.pressed)
 294         {
 295             led_set_layer(1);
 296         }
 297         break;
 298     case TO(2):
 299         if (record->event.pressed)
 300         {
 301             led_set_layer(2);
 302         }
 303         break;
 304     case TO(3):
 305         if (record->event.pressed)
 306         {
 307             led_set_layer(3);
 308         }
 309         break;
 310     case TO(4):
 311         if (record->event.pressed)
 312         {
 313             led_set_layer(4);
 314         }
 315         break;
 316     case TO(5):
 317         if (record->event.pressed)
 318         {
 319             led_set_layer(5);
 320         }
 321         break;
 322     }
 323     return true;
 324 }