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

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