keyboards/knops/mini/keymaps/default/keymap.c

   1 #include QMK_KEYBOARD_H
   2
   3 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   4
   5         LAYOUT(
   6                 LT(3, KC_MSTP), KC_VOLU, KC_MPLY, KC_MPRV, KC_VOLD, KC_MNXT),
   7
   8         LAYOUT(
   9                 LT(3, KC_ESC), M(3), M(4), M(5), M(6), M(7)),
  10
  11         LAYOUT(
  12                 LT(3, KC_1), KC_2, KC_3, KC_4, M(0), M(1)),
  13
  14         LAYOUT(
  15                 KC_TRNS, KC_TRNS, RESET, TO(0), TO(1), TO(2)),
  16
  17         LAYOUT(
  18                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  19
  20         LAYOUT(
  21                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  22
  23         LAYOUT(
  24                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  25
  26         LAYOUT(
  27                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  28
  29         LAYOUT(
  30                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  31
  32         LAYOUT(
  33                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  34
  35         LAYOUT(
  36                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  37
  38         LAYOUT(
  39                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  40
  41         LAYOUT(
  42                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  43
  44         LAYOUT(
  45                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  46
  47         LAYOUT(
  48                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  49
  50         LAYOUT(
  51                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)
  52
  53 };
  54
  55 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
  56         //keyevent_t event = record->event;
  57
  58         switch (id) {
  59                 case 0:
  60                         if (record->event.pressed) {
  61                                 return MACRO( T(T), T(G), T(L), T(H), T(F), T(ENT), END );
  62                         }
  63                         break;
  64                 case 1:
  65                         if (record->event.pressed) {
  66                                 return MACRO( T(T), T(G), T(G), T(ENT), END );
  67                         }
  68                         break;
  69                 case 2:
  70                         if (record->event.pressed) {
  71                                 return MACRO( D(NO), T(L), U(NO), END );
  72                         }
  73                         break;
  74                 case 3:
  75                         if (record->event.pressed) {
  76                                 return MACRO( D(LCTL), T(Z), U(LCTL), END );
  77                         }
  78                         break;
  79                 case 4:
  80                         if (record->event.pressed) {
  81                                 return MACRO( D(LCTL), D(LSFT), T(Z), U(LSFT), U(LCTL), END );
  82                         }
  83                         break;
  84                 case 5:
  85                         if (record->event.pressed) {
  86                                 return MACRO( D(LCTL), T(X), U(LCTL), END );
  87                         }
  88                         break;
  89                 case 6:
  90                         if (record->event.pressed) {
  91                                 return MACRO( D(LCTL), T(C), U(LCTL), END );
  92                         }
  93                         break;
  94                 case 7:
  95                         if (record->event.pressed) {
  96                                 return MACRO( D(LCTL), T(V), U(LCTL), END );
  97                         }
  98                         break;
  99         }
 100         return MACRO_NONE;
 101 }
 102
 103 void set_switch_led(int ledId, bool state) {
 104         if(state) {
 105                 switch(ledId) {
 106                         case 1:
 107                                 PORTD |= (1<<7);
 108                                 break;
 109                         case 2:
 110                                 if((PINB & (1 << 7)) != 0) {
 111                                         PORTC |= (1<<6);
 112                                 } else {
 113                                         PORTC |= (1<<7);
 114                                 }
 115                                 break;
 116                         case 3:
 117                                 PORTD |= (1<<4);
 118                                 break;
 119                         case 4:
 120                                 PORTE |= (1<<6);
 121                                 break;
 122                         case 5:
 123                                 PORTB |= (1<<4);
 124                                 break;
 125                         case 6:
 126                                 PORTD |= (1<<6);
 127                                 break;
 128                 }
 129         } else {
 130                 switch(ledId) {
 131                         case 1:
 132                                 PORTD &= ~(1<<7);
 133                                 break;
 134                         case 2:
 135                                 if((PINB & (1 << 7)) != 0) {
 136                                         PORTC &= ~(1<<6);
 137                                 } else {
 138                                         PORTC &= ~(1<<7);
 139                                 }
 140                                 break;
 141                         case 3:
 142                                 PORTD &= ~(1<<4);
 143                                 break;
 144                         case 4:
 145                                 PORTE &= ~(1<<6);
 146                                 break;
 147                         case 5:
 148                                 PORTB &= ~(1<<4);
 149                                 break;
 150                         case 6:
 151                                 PORTD &= ~(1<<6);
 152                                 break;
 153                 }
 154         }
 155 }
 156
 157
 158 void set_layer_led(int layerId) {
 159         PORTD |= (1<<5);
 160         PORTB &= ~(1<<6);
 161         PORTB |= (1<<0);
 162         switch(layerId) {
 163                 case 0:
 164                         PORTD &= ~(1<<5);
 165                         break;
 166                 case 1:
 167                         PORTB |= (1<<6);
 168                         break;
 169                 case 2:
 170                         PORTB &= ~(1<<0);
 171                         break;
 172         }
 173 }
 174
 175 void matrix_init_user(void) {
 176         led_init_ports();
 177
 178         PORTB |= (1 << 7);
 179         DDRB &= ~(1<<7);
 180
 181         PORTD |= (1<<7);
 182         PORTC |= (1<<6);
 183         PORTC |= (1<<7);
 184         PORTD |= (1<<4);
 185         PORTE |= (1<<6);
 186         PORTB |= (1<<4);
 187         PORTD |= (1<<6);
 188
 189         set_layer_led(0);
 190 }
 191
 192 void matrix_scan_user(void) {
 193 }
 194
 195 void led_init_ports() {
 196   // led voor switch #1
 197         DDRD |= (1<<7);
 198         PORTD &= ~(1<<7);
 199
 200   // led voor switch #2
 201         DDRC |= (1<<6);
 202         DDRC |= (1<<7);
 203         PORTC &= ~(1<<6);
 204         PORTC &= ~(1<<7);
 205
 206   // led voor switch #3
 207         DDRD |= (1<<4);
 208         PORTD &= ~(1<<4);
 209
 210   // led voor switch #4
 211         DDRE |= (1<<6);
 212         PORTE &= ~(1<<6);
 213
 214   // led voor switch #5
 215         DDRB |= (1<<4);
 216         PORTB &= ~(1<<4);
 217
 218   // led voor switch #6
 219         DDRD |= (1<<6);
 220         PORTD &= ~(1<<6);
 221
 222         /*
 223         DDRD |= (1<<7);
 224         PORTD |= (1<<7);
 225
 226         DDRC |= (1<<6);
 227         PORTC |= (1<<6);
 228
 229         DDRD |= (1<<4);
 230         PORTD |= (1<<4);
 231
 232         DDRE |= (1<<6);
 233         PORTE |= (1<<6);
 234
 235         DDRB |= (1<<4);
 236         PORTB |= (1<<4);
 237
 238         DDRD |= (1<<6);
 239         PORTD |= (1<<6);
 240         // */
 241
 242         DDRD |= (1<<5);
 243         DDRB |= (1<<6);
 244         DDRB |= (1<<0);
 245         //led_set_layer(0);
 246 }
 247
 248 void led_set_user(uint8_t usb_led) {
 249
 250         if (usb_led & (1 << USB_LED_NUM_LOCK)) {
 251
 252         } else {
 253
 254         }
 255
 256         if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
 257
 258         } else {
 259
 260         }
 261
 262         if (usb_led & (1 << USB_LED_SCROLL_LOCK)) {
 263
 264         } else {
 265
 266         }
 267
 268         if (usb_led & (1 << USB_LED_COMPOSE)) {
 269
 270         } else {
 271
 272         }
 273
 274         if (usb_led & (1 << USB_LED_KANA)) {
 275
 276         } else {
 277
 278         }
 279
 280 }
 281
 282
 283 /*
 284 *   NOTE:
 285 *
 286 *   In case you don't understand this coding stuff, please
 287 *   feel free to mail me or post something
 288 *   at the /r/knops subreddit and I will configure the code as
 289 *   you wish for your needs to make the LEDs do what you want :-).
 290 *
 291 *   Contact me at:    support@knops.io
 292 *
 293 *
 294 *       Knops Mini LED Numbers:
 295 *        _____   _____   _____
 296 *       |         | |     | |     |
 297 *       |  1  | |  2  | |  3  |    <---
 298 *       |_____| |_____| |_____|       |      These LEDs are called 'Switch LEDs'
 299 *        _____   _____   _____        |----- To turn on/off these leds, use:
 300 *       |         | |     | |     |       |       set_switch_led( [1-6], [true/false]);
 301 *       |  4  | |  5  | |  6  |    <---
 302 *       |_____| |_____| |_____|
 303 *
 304 *        < 0 >   < 1 >   < 2 >     <---      These front-LEDs are called 'Layer LEDs'
 305 *                                                                    To turn one of them on, use:
 306 *                                                                                set_layer_led( [0-2] );
 307 *
 308 */
 309
 310 /*
 311 * This function led_set_layer gets called when you switch between layers.
 312 * It allows you to turn on and off leds for each different layer and do
 313 * other cool stuff. Currently the GUI does not have LED support. I am working
 314 * on that, but takes time.
 315 */
 316 void led_set_layer(int layer) {
 317         switch(layer) {
 318
 319                         /**
 320                         *   Here is an example to turn LEDs on and of. By default:
 321                         *   - the LEDs are turned on in layer 0
 322                         *   - the LEDs are turned off in layer 1
 323                         *   - the LEDs don't change from state for layer 2
 324                         */
 325
 326                 case 0:
 327                         set_layer_led(0); // Turn on only the first/left layer indicator
 328                         set_switch_led(1, true);
 329                         set_switch_led(2, true);
 330                         set_switch_led(3, true);
 331                         set_switch_led(4, true);
 332                         set_switch_led(5, true);
 333                         set_switch_led(6, true);
 334                         break;
 335
 336                 case 1:
 337                         set_layer_led(1); // Turn on only the second/middle layer indicator
 338                         set_switch_led(1, false);
 339                         set_switch_led(2, false);
 340                         set_switch_led(3, false);
 341                         set_switch_led(4, false);
 342                         set_switch_led(5, false);
 343                         set_switch_led(6, false);
 344                         break;
 345
 346                 case 2:
 347                         set_layer_led(2); // Turn on only the third/right layer indicator
 348
 349                         // Keep leds for layer two in their current state, since we don't use set_switch_led(SWITCH_ID, TRUE_OR_FALSE)
 350
 351                         break;
 352         }
 353 }
 354
 355 bool process_record_user (uint16_t keycode, keyrecord_t *record) {
 356   switch(keycode) {
 357   case TO(0):
 358       if (record->event.pressed) {
 359         led_set_layer(0);
 360      }
 361      break;
 362   case TO(1):
 363       if (record->event.pressed) {
 364         led_set_layer(1);
 365      }
 366      break;
 367   case TO(2):
 368       if (record->event.pressed) {
 369         led_set_layer(2);
 370      }
 371      break;
 372   }
 373   return true;
 374 }