keyboards/knops/mini/keymaps/default-gsm-newbs/keymap.c

   1 #include QMK_KEYBOARD_H
   2
   3 /*
   4 *  Copy of knopps mini default May 16,2018
   5 *  Added comments in code to more easilly understand it.
   6 *
   7 *   Key Layout
   8 *        _____   _____   _____
   9 *       |         | |     | |     |
  10 *       |  1  | |  2  | |  3  |
  11 *       |_____| |_____| |_____|
  12 *        _____   _____   _____
  13 *       |         | |     | |     |
  14 *       |  4  | |  5  | |  6  |
  15 *       |_____| |_____| |_____|
  16 *
  17 *  Each Layout row below keys. 1,2,3,4,5,6
  18 *
  19 *  Hold 3 when powering on for DFU Program Mode
  20 */
  21
  22 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  23
  24 /*
  25 *   Layer 0 (Default)
  26 *        _____   _____   _____
  27 *       |         | |     | |     |
  28 *        Stop    VolUp   Play
  29 *       |_____| |_____| |_____|
  30 *        _____   _____   _____
  31 *       |         | |     | |     |
  32 *        Prev    VolDwn  Next
  33 *       |_____| |_____| |_____|
  34 *
  35 * Button 1 (stop) is Held to activate Layer 3 only while held, User then selects the keymap to change to
  36 */
  37         LAYOUT(
  38                 LT(3, KC_MSTP), KC_VOLU, KC_MPLY, KC_MPRV, KC_VOLD, KC_MNXT),
  39
  40 /*
  41 *   Layer 1
  42 *        _____   _____   _____
  43 *       |         | |     | |     |
  44 *         ESC    Macro3  Macro4
  45 *       |_____| |_____| |_____|
  46 *        _____   _____   _____
  47 *       |         | |     | |     |
  48 *        Macro5  Macro6  Macro7
  49 *       |_____| |_____| |_____|
  50 *
  51 */
  52         LAYOUT(
  53                 LT(3, KC_ESC), M(3), M(4), M(5), M(6), M(7)),
  54
  55 /*
  56 *   Layer 2
  57 *        _____   _____   _____
  58 *       |         | |     | |     |
  59 *       |  1  | |  2  | |  3  |
  60 *       |_____| |_____| |_____|
  61 *        _____   _____   _____
  62 *       |         | |     | |     |
  63 *       |  4  | |Macro0  Macro1
  64 *       |_____| |_____| |_____|
  65 *
  66 */
  67         LAYOUT(
  68                 LT(3, KC_1), KC_2, KC_3, KC_4, M(0), M(1)),
  69
  70 /*
  71 *  Layer 3 Key Layout
  72 *  This Layer does the Layer Selection
  73 *        _____   _____   _____
  74 *       |         | |     | | DFU
  75 *       |None | |None | | FLash
  76 *       |_____| |_____| |_____|
  77 *        _____   _____   _____
  78 *       |         | |     | |     |
  79 *        Layer   Layer  Layer
  80 *    0       1       2
  81 *       |_____| |_____| |_____|
  82 *
  83 * Layers 0,1,2 have Button 1 held to activate this layer. Then press the specific layer to switch to it.
  84 *
  85 */
  86         LAYOUT(
  87                 KC_TRNS, KC_TRNS, RESET, TO(0), TO(1), TO(2)),
  88
  89 // More Layers that can be used, but are not by default
  90
  91         LAYOUT(
  92                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  93
  94         LAYOUT(
  95                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  96
  97         LAYOUT(
  98                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
  99
 100         LAYOUT(
 101                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
 102
 103         LAYOUT(
 104                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
 105
 106         LAYOUT(
 107                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
 108
 109         LAYOUT(
 110                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
 111
 112         LAYOUT(
 113                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
 114
 115         LAYOUT(
 116                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
 117
 118         LAYOUT(
 119                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
 120
 121         LAYOUT(
 122                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
 123
 124         LAYOUT(
 125                 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)
 126
 127 };
 128
 129 //  Older way of Macros found here: https://docs.qmk.fm/features/macros
 130
 131 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
 132         //keyevent_t event = record->event;
 133
 134         switch (id) {
 135                 case 0:
 136                         if (record->event.pressed) {
 137                         /*
 138                         * This is Macro 0
 139                         * Content:  tglhf<enter>
 140                         */
 141                                 return MACRO( T(T), T(G), T(L), T(H), T(F), T(ENT), END );
 142                         }
 143                         break;
 144                 case 1:
 145                         if (record->event.pressed) {
 146                         /*
 147                         * This is Macro 1
 148                         * Content:  tgg<enter>
 149                         */
 150                                 return MACRO( T(T), T(G), T(G), T(ENT), END );
 151                         }
 152                         break;
 153                 case 2:
 154                         if (record->event.pressed) {
 155                         /*
 156                         * This is Macro 2
 157                         * Content:  Press and hold "no" , type "l", release "no"<enter>
 158                         * I haven't found what this "NO" key maps to
 159                         */
 160                                 return MACRO( D(NO), T(L), U(NO), END );
 161                         }
 162                         break;
 163                 case 3:
 164                         if (record->event.pressed) {
 165                         /*
 166                         * This is Macro 3
 167                         * Content:  press/hold LCTRL, type "2", release LCTRL
 168                         */
 169                                 return MACRO( D(LCTL), T(Z), U(LCTL), END );
 170                         }
 171                         break;
 172                 case 4:
 173                         if (record->event.pressed) {
 174                         /*
 175                         * This is Macro 4
 176                         * Content:  press/hold LCTRL, type "2", release LCTRL
 177                         */
 178                                 return MACRO( D(LCTL), D(LSFT), T(Z), U(LSFT), U(LCTL), END );
 179                         }
 180                         break;
 181                 case 5:
 182                         if (record->event.pressed) {
 183                         /*
 184                         * This is Macro 5
 185                         * Content:  press/hold LCTRL, type "x", release LCTRL
 186                         */
 187                                 return MACRO( D(LCTL), T(X), U(LCTL), END );
 188                         }
 189                         break;
 190                 case 6:
 191                         if (record->event.pressed) {
 192                         /*
 193                         * This is Macro 6
 194                         * Content:  press/hold LCTRL, type "c", release LCTRL
 195                         */
 196                                 return MACRO( D(LCTL), T(C), U(LCTL), END );
 197                         }
 198                         break;
 199                 case 7:
 200                         if (record->event.pressed) {
 201                         /*
 202                         * This is Macro 7
 203                         * Content:  press/hold LCTRL, type "v", release LCTRL
 204                         */
 205                                 return MACRO( D(LCTL), T(V), U(LCTL), END );
 206                         }
 207                         break;
 208         }
 209         return MACRO_NONE;
 210 }
 211
 212
 213
 214 void set_switch_led(int ledId, bool state) {
 215         if(state) {
 216                 switch(ledId) {
 217                         case 1:
 218                                 PORTD |= (1<<7);
 219                                 break;
 220                         case 2:
 221                                 if((PINB & (1 << 7)) != 0) {
 222                                         PORTC |= (1<<6);
 223                                 } else {
 224                                         PORTC |= (1<<7);
 225                                 }
 226                                 break;
 227                         case 3:
 228                                 PORTD |= (1<<4);
 229                                 break;
 230                         case 4:
 231                                 PORTE |= (1<<6);
 232                                 break;
 233                         case 5:
 234                                 PORTB |= (1<<4);
 235                                 break;
 236                         case 6:
 237                                 PORTD |= (1<<6);
 238                                 break;
 239                 }
 240         } else {
 241                 switch(ledId) {
 242                         case 1:
 243                                 PORTD &= ~(1<<7);
 244                                 break;
 245                         case 2:
 246                                 if((PINB & (1 << 7)) != 0) {
 247                                         PORTC &= ~(1<<6);
 248                                 } else {
 249                                         PORTC &= ~(1<<7);
 250                                 }
 251                                 break;
 252                         case 3:
 253                                 PORTD &= ~(1<<4);
 254                                 break;
 255                         case 4:
 256                                 PORTE &= ~(1<<6);
 257                                 break;
 258                         case 5:
 259                                 PORTB &= ~(1<<4);
 260                                 break;
 261                         case 6:
 262                                 PORTD &= ~(1<<6);
 263                                 break;
 264                 }
 265         }
 266 }
 267
 268
 269 void set_layer_led(int layerId) {
 270         PORTD |= (1<<5);
 271         PORTB &= ~(1<<6);
 272         PORTB |= (1<<0);
 273         switch(layerId) {
 274                 case 0:
 275                         PORTD &= ~(1<<5);
 276                         break;
 277                 case 1:
 278                         PORTB |= (1<<6);
 279                         break;
 280                 case 2:
 281                         PORTB &= ~(1<<0);
 282                         break;
 283         }
 284 }
 285
 286 void matrix_init_user(void) {
 287         led_init_ports();
 288
 289         PORTB |= (1 << 7);
 290         DDRB &= ~(1<<7);
 291
 292         PORTD |= (1<<7);
 293         PORTC |= (1<<6);
 294         PORTC |= (1<<7);
 295         PORTD |= (1<<4);
 296         PORTE |= (1<<6);
 297         PORTB |= (1<<4);
 298         PORTD |= (1<<6);
 299
 300         set_layer_led(0);
 301 }
 302
 303 void matrix_scan_user(void) {
 304 }
 305
 306 void led_init_ports() {
 307   // led voor switch #1
 308         DDRD |= (1<<7);
 309         PORTD &= ~(1<<7);
 310
 311   // led voor switch #2
 312         DDRC |= (1<<6);
 313         DDRC |= (1<<7);
 314         PORTC &= ~(1<<6);
 315         PORTC &= ~(1<<7);
 316
 317   // led voor switch #3
 318         DDRD |= (1<<4);
 319         PORTD &= ~(1<<4);
 320
 321   // led voor switch #4
 322         DDRE |= (1<<6);
 323         PORTE &= ~(1<<6);
 324
 325   // led voor switch #5
 326         DDRB |= (1<<4);
 327         PORTB &= ~(1<<4);
 328
 329   // led voor switch #6
 330         DDRD |= (1<<6);
 331         PORTD &= ~(1<<6);
 332
 333         /*
 334         DDRD |= (1<<7);
 335         PORTD |= (1<<7);
 336
 337         DDRC |= (1<<6);
 338         PORTC |= (1<<6);
 339
 340         DDRD |= (1<<4);
 341         PORTD |= (1<<4);
 342
 343         DDRE |= (1<<6);
 344         PORTE |= (1<<6);
 345
 346         DDRB |= (1<<4);
 347         PORTB |= (1<<4);
 348
 349         DDRD |= (1<<6);
 350         PORTD |= (1<<6);
 351         // */
 352
 353         DDRD |= (1<<5);
 354         DDRB |= (1<<6);
 355         DDRB |= (1<<0);
 356         //led_set_layer(0);
 357 }
 358
 359 void led_set_user(uint8_t usb_led) {
 360
 361         if (usb_led & (1 << USB_LED_NUM_LOCK)) {
 362
 363         } else {
 364
 365         }
 366
 367         if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
 368
 369         } else {
 370
 371         }
 372
 373         if (usb_led & (1 << USB_LED_SCROLL_LOCK)) {
 374
 375         } else {
 376
 377         }
 378
 379         if (usb_led & (1 << USB_LED_COMPOSE)) {
 380
 381         } else {
 382
 383         }
 384
 385         if (usb_led & (1 << USB_LED_KANA)) {
 386
 387         } else {
 388
 389         }
 390
 391 }
 392
 393
 394 /*
 395 *   NOTE:
 396 *
 397 *   In case you don't understand this coding stuff, please
 398 *   feel free to mail me or post something
 399 *   at the /r/knops subreddit and I will configure the code as
 400 *   you wish for your needs to make the LEDs do what you want :-).
 401 *
 402 *   Contact me at:    support@knops.io
 403 *
 404 *
 405 *       Knops Mini LED Numbers:
 406 *        _____   _____   _____
 407 *       |         | |     | |     |
 408 *       |  1  | |  2  | |  3  |    <---
 409 *       |_____| |_____| |_____|       |      These LEDs are called 'Switch LEDs'
 410 *        _____   _____   _____        |----- To turn on/off these leds, use:
 411 *       |         | |     | |     |       |       set_switch_led( [1-6], [true/false]);
 412 *       |  4  | |  5  | |  6  |    <---
 413 *       |_____| |_____| |_____|
 414 *
 415 *        < 0 >   < 1 >   < 2 >     <---      These front-LEDs are called 'Layer LEDs'
 416 *                                                                    To turn one of them on, use:
 417 *                                                                                set_layer_led( [0-2] );
 418 *
 419 */
 420
 421 /*
 422 * This function led_set_layer gets called when you switch between layers.
 423 * It allows you to turn on and off leds for each different layer and do
 424 * other cool stuff. Currently the GUI does not have LED support. I am working
 425 * on that, but takes time.
 426 */
 427 void led_set_layer(int layer) {
 428         switch(layer) {
 429
 430                         /**
 431                         *   Here is an example to turn LEDs on and of. By default:
 432                         *   - the LEDs are turned on in layer 0
 433                         *   - the LEDs are turned off in layer 1
 434                         *   - the LEDs don't change from state for layer 2
 435                         */
 436
 437                 case 0:
 438                         set_layer_led(0); // Turn on only the first/left layer indicator
 439                         set_switch_led(1, true);
 440                         set_switch_led(2, true);
 441                         set_switch_led(3, true);
 442                         set_switch_led(4, true);
 443                         set_switch_led(5, true);
 444                         set_switch_led(6, true);
 445                         break;
 446
 447                 case 1:
 448                         set_layer_led(1); // Turn on only the second/middle layer indicator
 449                         set_switch_led(1, false);
 450                         set_switch_led(2, false);
 451                         set_switch_led(3, false);
 452                         set_switch_led(4, false);
 453                         set_switch_led(5, false);
 454                         set_switch_led(6, false);
 455                         break;
 456
 457                 case 2:
 458                         set_layer_led(2); // Turn on only the third/right layer indicator
 459
 460                         // Keep leds for layer two in their current state, since we don't use set_switch_led(SWITCH_ID, TRUE_OR_FALSE)
 461
 462                         break;
 463         }
 464 }
 465
 466 bool process_record_user (uint16_t keycode, keyrecord_t *record) {
 467   switch(keycode) {
 468   case TO(0):
 469       if (record->event.pressed) {
 470         led_set_layer(0);
 471      }
 472      break;
 473   case TO(1):
 474       if (record->event.pressed) {
 475         led_set_layer(1);
 476      }
 477      break;
 478   case TO(2):
 479       if (record->event.pressed) {
 480         led_set_layer(2);
 481      }
 482      break;
 483   }
 484   return true;
 485 }