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

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