aboutsummaryrefslogtreecommitdiff
path: root/Model01-Firmware.ino
blob: fff564c836b70f0b6705c6c0a29ddb44fe65ca4c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
// -*- mode: c++ -*- 
// Copyright 2016 Keyboardio, inc. <jesse@keyboard.io> 
// See "LICENSE" for license details 
 
#ifndef BUILD_INFORMATION
#define BUILD_INFORMATION "locally built"
#endif
 
 
/**
 * These #include directives pull in the Kaleidoscope firmware core,
 * as well as the Kaleidoscope plugins we use in the Model 01's firmware
 */
 
 
// The Kaleidoscope core 
#include "Kaleidoscope.h"
 
// Support for storing the keymap in EEPROM 
#include "Kaleidoscope-EEPROM-Settings.h"
#include "Kaleidoscope-EEPROM-Keymap.h"
 
// Support for communicating with the host via a simple Serial protocol 
#include "Kaleidoscope-FocusSerial.h"
 
// Support for keys that move the mouse 
#include "Kaleidoscope-MouseKeys.h"
 
// Support for macros 
#include "Kaleidoscope-Macros.h"
 
// Support for controlling the keyboard's LEDs 
#include "Kaleidoscope-LEDControl.h"
 
// Support for "Numpad" mode, which is mostly just the Numpad specific LED mode 
#include "Kaleidoscope-NumPad.h"
 
// Support for the "Boot greeting" effect, which pulses the 'LED' button for 10s 
// when the keyboard is connected to a computer (or that computer is powered on) 
#include "Kaleidoscope-LEDEffect-BootGreeting.h"
 
// Support for LED modes that set all LEDs to a single color 
#include "Kaleidoscope-LEDEffect-SolidColor.h"
 
// Support for Keyboardio's internal keyboard testing mode 
#include "Kaleidoscope-Model01-TestMode.h"
 
// Support for host power management (suspend & wakeup) 
#include "Kaleidoscope-HostPowerManagement.h"
 
// Support for magic combos (key chords that trigger an action) 
#include "Kaleidoscope-MagicCombo.h"
 
// Support for USB quirks, like changing the key state report protocol 
#include "Kaleidoscope-USB-Quirks.h"
 
/** This 'enum' is a list of all the macros used by the Model 01's firmware
  * The names aren't particularly important. What is important is that each
  * is unique.
  *
  * These are the names of your macros. They'll be used in two places.
  * The first is in your keymap definitions. There, you'll use the syntax
  * `M(MACRO_NAME)` to mark a specific keymap position as triggering `MACRO_NAME`
  *
  * The second usage is in the 'switch' statement in the `macroAction` function.
  * That switch statement actually runs the code associated with a macro when
  * a macro key is pressed.
  */
 
enum { MACRO_VERSION_INFO,
       MACRO_ANY
     };
 
 
 
/** The Model 01's key layouts are defined as 'keymaps'. By default, there are three
  * keymaps: The standard QWERTY keymap, the "Function layer" keymap and the "Numpad"
  * keymap.
  *
  * Each keymap is defined as a list using the 'KEYMAP_STACKED' macro, built
  * of first the left hand's layout, followed by the right hand's layout.
  *
  * Keymaps typically consist mostly of `Key_` definitions. There are many, many keys
  * defined as part of the USB HID Keyboard specification. You can find the names
  * (if not yet the explanations) for all the standard `Key_` defintions offered by
  * Kaleidoscope in these files:
  *    https://github.com/keyboardio/Kaleidoscope/blob/master/src/key_defs_keyboard.h
  *    https://github.com/keyboardio/Kaleidoscope/blob/master/src/key_defs_consumerctl.h
  *    https://github.com/keyboardio/Kaleidoscope/blob/master/src/key_defs_sysctl.h
  *    https://github.com/keyboardio/Kaleidoscope/blob/master/src/key_defs_keymaps.h
  *
  * Additional things that should be documented here include
  *   using ___ to let keypresses fall through to the previously active layer
  *   using XXX to mark a keyswitch as 'blocked' on this layer
  *   using ShiftToLayer() and LockLayer() keys to change the active keymap.
  *   keeping NUM and FN consistent and accessible on all layers
  *
  * The PROG key is special, since it is how you indicate to the board that you
  * want to flash the firmware. However, it can be remapped to a regular key.
  * When the keyboard boots, it first looks to see whether the PROG key is held
  * down; if it is, it simply awaits further flashing instructions. If it is
  * not, it continues loading the rest of the firmware and the keyboard
  * functions normally, with whatever binding you have set to PROG. More detail
  * here: https://community.keyboard.io/t/how-the-prog-key-gets-you-into-the-bootloader/506/8
  *
  * The "keymaps" data structure is a list of the keymaps compiled into the firmware.
  * The order of keymaps in the list is important, as the ShiftToLayer(#) and LockLayer(#)
  * macros switch to key layers based on this list.
  *
  *
 
  * A key defined as 'ShiftToLayer(FUNCTION)' will switch to FUNCTION while held.
  * Similarly, a key defined as 'LockLayer(NUMPAD)' will switch to NUMPAD when tapped.
  */
 
/**
  * Layers are "0-indexed" -- That is the first one is layer 0. The second one is layer 1.
  * The third one is layer 2.
  * This 'enum' lets us use names like QWERTY, FUNCTION, and NUMPAD in place of
  * the numbers 0, 1 and 2.
  *
  */
 
enum { PRIMARY, NUMPAD, FUNCTION, FVWM }// layers 
 
 
/**
  * To change your keyboard's layout from QWERTY to DVORAK or COLEMAK, comment out the line
  *
  * #define PRIMARY_KEYMAP_QWERTY
  *
  * by changing it to
  *
  * // #define PRIMARY_KEYMAP_QWERTY
  *
  * Then uncomment the line corresponding to the layout you want to use.
  *
  */
 
#define PRIMARY_KEYMAP_QWERTY
// #define PRIMARY_KEYMAP_DVORAK 
 
 
 
/* This comment temporarily turns off astyle's indent enforcement
 *   so we can make the keymaps actually resemble the physical key layout better
 */
// *INDENT-OFF* 
 
KEYMAPS(
 
#if defined (PRIMARY_KEYMAP_QWERTY)
  [PRIMARY] = KEYMAP_STACKED
  (___,          Key_1, Key_2, Key_3, Key_4, Key_5, Key_LEDEffectNext,
   Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab,
   Key_PageUp,   Key_A, Key_S, Key_D, Key_F, Key_G,
   Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape,
   Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,
   ShiftToLayer(FVWM),
 
   M(MACRO_ANY),  Key_6, Key_7, Key_8,     Key_9,         Key_0,         LockLayer(NUMPAD),
   Key_Enter,     Key_Y, Key_U, Key_I,     Key_O,         Key_P,         Key_Equals,
                  Key_H, Key_J, Key_K,     Key_L,         Key_Semicolon, Key_Quote,
   Key_RightAlt,  Key_N, Key_M, Key_Comma, Key_Period,    Key_Slash,     Key_Minus,
   Key_RightShift, Key_LeftAlt, Key_Spacebar, Key_RightControl,
   ShiftToLayer(FUNCTION)),
 
#elif defined (PRIMARY_KEYMAP_DVORAK)
 
  [PRIMARY] = KEYMAP_STACKED
  (___,          Key_1,         Key_2,     Key_3,      Key_4, Key_5, Key_LEDEffectNext,
   Key_Backtick, Key_Quote,     Key_Comma, Key_Period, Key_P, Key_Y, Key_Tab,
   Key_PageUp,   Key_A,         Key_O,     Key_E,      Key_U, Key_I,
   Key_PageDown, Key_Semicolon, Key_Q,     Key_J,      Key_K, Key_X, Key_Escape,
   Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,
   ShiftToLayer(FVWM),
 
   M(MACRO_ANY),   Key_6, Key_7, Key_8, Key_9, Key_0, LockLayer(NUMPAD),
   Key_Enter,      Key_F, Key_G, Key_C, Key_R, Key_L, Key_Slash,
                   Key_D, Key_H, Key_T, Key_N, Key_S, Key_Minus,
   Key_RightAlt,   Key_B, Key_M, Key_W, Key_V, Key_Z, Key_Equals,
   Key_RightShift, Key_LeftAlt, Key_Spacebar, Key_RightControl,
   ShiftToLayer(FUNCTION)),
 
#else
 
#error "No default keymap defined. You should make sure that you have a line like '#define PRIMARY_KEYMAP_QWERTY' in your sketch"
 
#endif
 
 
 
  [NUMPAD] =  KEYMAP_STACKED
  (___, ___, ___, ___, ___, ___, ___,
   ___, ___, ___, ___, ___, ___, ___,
   ___, ___, ___, ___, ___, ___,
   ___, ___, ___, ___, ___, ___, ___,
   ___, ___, ___, ___,
   ___,
 
   M(MACRO_VERSION_INFO),  ___, Key_Keypad7, Key_Keypad8,   Key_Keypad9,        Key_KeypadSubtract, ___,
   ___,                    ___, Key_Keypad4, Key_Keypad5,   Key_Keypad6,        Key_KeypadAdd,      ___,
                           ___, Key_Keypad1, Key_Keypad2,   Key_Keypad3,        Key_Equals,         ___,
   ___,                    ___, Key_Keypad0, Key_KeypadDot, Key_KeypadMultiply, Key_KeypadDivide,   Key_Enter,
   ___, ___, ___, ___,
   ___),
 
  [FUNCTION] =  KEYMAP_STACKED
  (___,      Key_F1,           Key_F2,      Key_F3,     Key_F4,        Key_F5,           Key_CapsLock,
   Key_Tab,  ___,              Key_mouseUp, ___,        Key_mouseBtnR, Key_mouseWarpEnd, Key_mouseWarpNE,
   Key_Home, Key_mouseL,       Key_mouseDn, Key_mouseR, Key_mouseBtnL, Key_mouseWarpNW,
   Key_End,  Key_PrintScreen,  Key_Insert,  ___,        Key_mouseBtnM, Key_mouseWarpSW,  Key_mouseWarpSE,
   ___, Key_Delete, ___, ___,
   ___,
 
   ___,               Key_F6,        Key_F7,               Key_F8,                Key_F9,          Key_F10,          Key_F11,
   ___,               ___,           Key_LeftCurlyBracket, Key_RightCurlyBracket, Key_LeftBracket, Key_RightBracket, Key_F12,
                      Key_LeftArrow, Key_DownArrow,        Key_UpArrow,           Key_RightArrow,  ___,              ___,
   Key_PcApplication, ___,           ___,                  ___,                   ___,             Key_Backslash,    Key_Pipe,
   ___, ___, Key_Enter, ___,
   ___),
 
  [FVWM] =  KEYMAP_STACKED
  (___, Key_BacklightDown, Key_BacklightUp,   LALT(Key_F1),      LALT(Key_F2),      ___,               ___,
   ___, ___,               ___,               ___,               ___,               ___,               ___,
   ___, ___,               LALT(Key_Keypad4), LALT(Key_Keypad2), LALT(Key_Keypad8), LALT(Key_Keypad6),
   ___, ___,               ___,               ___,               ___,               ___,               LALT(Key_KeypadMultiply),
   ___, LALT(Key_Backtick), LSHIFT(LALT(Key_Backtick)), ___,
   ___,
 
   ___,                 Consumer_Mute,       Consumer_VolumeDecrement, Consumer_VolumeIncrement, ___,                  Consumer_Eject, ___,
   ___,                 ___,                 ___,                      ___,                      ___,                  ___,            LSHIFT(LALT(Key_KeypadDivide)),
                        LALT(Key_LeftArrow), LALT(Key_DownArrow),      LALT(Key_UpArrow),        LALT(Key_RightArrow), ___,            LSHIFT(LALT(Key_KeypadEnter)),
   LALT(Key_Pause),     ___,                 ___,                      ___,                      ___,                  LALT(Key_M),    LSHIFT(LALT(Key_KeypadDot)),
   ___, ___, ___, ___,
   ___)
// KEYMAPS( 
 
/* Re-enable astyle's indent enforcement */
// *INDENT-ON* 
 
class DakkarColor: public kaleidoscope::plugin::LEDMode {
private:
  static constexpr cRGB color_off = CRGB(0,0,0);
 
  static constexpr cRGB color_window = CRGB(255,0,0);
  static constexpr cRGB color_viewport = CRGB(0,255,0);
  static constexpr cRGB color_lauch = CRGB(0,0,255);
 
  static constexpr cRGB color_mouse = CRGB(0,0,255);
  static constexpr cRGB color_mouse_button = CRGB(0,128,128);
  static constexpr cRGB color_mouse_warp = CRGB(64,128,128);
  static constexpr cRGB color_function = CRGB(64,128,64);
 
  cRGB color_layer;
public:
  DakkarColor(cRGB layer) : color_layer(layer) { }
protected:
  void update(void) final {
    for (uint8_t r = 0; r < ROWS; r++) {
      for (uint8_t c = 0; c < COLS; c++) {
        this->refreshAt(r, c);
      }
    }
  }
  void refreshAt(byte r, byte c) final {
    Key k = Layer.lookupOnActiveLayer(r, c);
    uint8_t current_layer = Layer.top();
    Key layer_key = Layer.getKey(current_layer, r, c);
    bool is_on_layer = (k == layer_key && k != Key_NoKey);
 
    cRGB color = color_off;
    if (current_layer == FVWM) { // FVWM keys 
      if (is_on_layer) {
        color = color_window;
      }
      switch (k.keyCode{
      case Key_F1.keyCode ... Key_F12.keyCodecase Key_Backtick.keyCode:
        color = color_lauch; break;
 
      case Key_LeftArrow.keyCodecase Key_RightArrow.keyCodecase Key_UpArrow.keyCodecase Key_DownArrow.keyCode:
        color = color_viewport; break;
      }
      if (k.flags & SHIFT_HELD) {
        color.r >>= 1; color.g >>= 1; color.b >>= 1;
      }
    }
    else if (current_layer == FUNCTION) {
      if (k.flags & IS_MOUSE_KEY) {
        switch (k.keyCode{
        case Key_mouseUp.keyCodecase Key_mouseDn.keyCodecase Key_mouseL.keyCodecase Key_mouseR.keyCode:
          color = color_mouse; break;
        }
        if (k.keyCode & KEY_MOUSE_WARP) { color = color_mouse_warp; }
        else if (k.keyCode & KEY_MOUSE_BUTTON) { color = color_mouse_button; }
      }
      else if (is_on_layer) {
        color = color_function;
      }
    }
    else { // only light up keys that are specific to this layer 
      if (k == layer_key && k != Key_NoKey) {
        color = color_layer;
      }
    }
 
    LEDControl.setCrgbAt(r, c, color);
  }
};
 
static DakkarColor DakkarColorDark(CRGB(0,0,0));
static DakkarColor DakkarColorBright(CRGB(0,0,150));
 
/** versionInfoMacro handles the 'firmware version info' macro
 *  When a key bound to the macro is pressed, this macro
 *  prints out the firmware build information as virtual keystrokes
 */
 
static void versionInfoMacro(uint8_t keyState) {
  if (keyToggledOn(keyState)) {
    Macros.type(PSTR("Keyboardio Model 01 - Kaleidoscope "));
    Macros.type(PSTR(BUILD_INFORMATION));
  }
}
 
/** anyKeyMacro is used to provide the functionality of the 'Any' key.
 *
 * When the 'any key' macro is toggled on, a random alphanumeric key is
 * selected. While the key is held, the function generates a synthetic
 * keypress event repeating that randomly selected key.
 *
 */
 
static void anyKeyMacro(uint8_t keyState) {
  static Key lastKey;
  bool toggledOn = false;
  if (keyToggledOn(keyState)) {
    lastKey.keyCode = Key_A.keyCode + (uint8_t)(millis() % 36);
    toggledOn = true;
  }
 
  if (keyIsPressed(keyState))
    kaleidoscope::hid::pressKey(lastKey, toggledOn);
}
 
 
/** macroAction dispatches keymap events that are tied to a macro
    to that macro. It takes two uint8_t parameters.
 
    The first is the macro being called (the entry in the 'enum' earlier in this file).
    The second is the state of the keyswitch. You can use the keyswitch state to figure out
    if the key has just been toggled on, is currently pressed or if it's just been released.
 
    The 'switch' statement should have a 'case' for each entry of the macro enum.
    Each 'case' statement should call out to a function to handle the macro in question.
 
 */
 
const macro_t *macroAction(uint8_t macroIndex, uint8_t keyState) {
  switch (macroIndex) {
 
  case MACRO_VERSION_INFO:
    versionInfoMacro(keyState);
    break;
 
  case MACRO_ANY:
    anyKeyMacro(keyState);
    break;
  }
  return MACRO_NONE;
}
 
 
 
/** toggleLedsOnSuspendResume toggles the LEDs off when the host goes to sleep,
 * and turns them back on when it wakes up.
 */
void toggleLedsOnSuspendResume(kaleidoscope::plugin::HostPowerManagement::Event event) {
  switch (event) {
  case kaleidoscope::plugin::HostPowerManagement::Suspend:
    LEDControl.set_all_leds_to({000});
    LEDControl.syncLeds();
    LEDControl.paused = true;
    break;
  case kaleidoscope::plugin::HostPowerManagement::Resume:
    LEDControl.paused = false;
    LEDControl.refreshAll();
    break;
  case kaleidoscope::plugin::HostPowerManagement::Sleep:
    break;
  }
}
 
/** hostPowerManagementEventHandler dispatches power management events (suspend,
 * resume, and sleep) to other functions that perform action based on these
 * events.
 */
void hostPowerManagementEventHandler(kaleidoscope::plugin::HostPowerManagement::Event event) {
  toggleLedsOnSuspendResume(event);
}
 
/** This 'enum' is a list of all the magic combos used by the Model 01's
 * firmware The names aren't particularly important. What is important is that
 * each is unique.
 *
 * These are the names of your magic combos. They will be used by the
 * `USE_MAGIC_COMBOS` call below.
 */
enum {
  // Toggle between Boot (6-key rollover; for BIOSes and early boot) and NKRO 
  // mode. 
  COMBO_TOGGLE_NKRO_MODE
};
 
/** A tiny wrapper, to be used by MagicCombo.
 * This simply toggles the keyboard protocol via USBQuirks, and wraps it within
 * a function with an unused argument, to match what MagicCombo expects.
 */
static void toggleKeyboardProtocol(uint8_t combo_index) {
  USBQuirks.toggleKeyboardProtocol();
}
 
/** Magic combo list, a list of key combo and action pairs the firmware should
 * recognise.
 */
USE_MAGIC_COMBOS({.action = toggleKeyboardProtocol,
                  // Left Fn + Esc + Shift 
                  .keys = { R3C6, R2C6, R3C7 }
                 });
 
// First, tell Kaleidoscope which plugins you want to use. 
// The order can be important. For example, LED effects are 
// added in the order they're listed here. 
KALEIDOSCOPE_INIT_PLUGINS(
  // The EEPROMSettings & EEPROMKeymap plugins make it possible to have an 
  // editable keymap in EEPROM. 
  EEPROMSettings,
  EEPROMKeymap,
 
  // Focus allows bi-directional communication with the host, and is the 
  // interface through which the keymap in EEPROM can be edited. 
  Focus,
 
  // FocusSettingsCommand adds a few Focus commands, intended to aid in 
  // changing some settings of the keyboard, such as the default layer (via the 
  // `settings.defaultLayer` command) 
  FocusSettingsCommand,
 
  // FocusEEPROMCommand adds a set of Focus commands, which are very helpful in 
  // both debugging, and in backing up one's EEPROM contents. 
  FocusEEPROMCommand,
 
  // The boot greeting effect pulses the LED button for 10 seconds after the 
  // keyboard is first connected 
  BootGreetingEffect,
 
  // The hardware test mode, which can be invoked by tapping Prog, LED and the 
  // left Fn button at the same time. 
  TestMode,
 
  // LEDControl provides support for other LED modes 
  LEDControl,
 
  DakkarColorDark, DakkarColorBright,
 
  // The numpad plugin is responsible for lighting up the 'numpad' mode 
  // with a custom LED effect 
  NumPad,
 
  // The macros plugin adds support for macros 
  Macros,
 
  // The MouseKeys plugin lets you add keys to your keymap which move the mouse. 
  MouseKeys,
 
  // The HostPowerManagement plugin allows us to turn LEDs off when then host 
  // goes to sleep, and resume them when it wakes up. 
  HostPowerManagement,
 
  // The MagicCombo plugin lets you use key combinations to trigger custom 
  // actions - a bit like Macros, but triggered by pressing multiple keys at the 
  // same time. 
  MagicCombo,
 
  // The USBQuirks plugin lets you do some things with USB that we aren't 
  // comfortable - or able - to do automatically, but can be useful 
  // nevertheless. Such as toggling the key report protocol between Boot (used 
  // by BIOSes) and Report (NKRO). 
  USBQuirks
);
 
/** The 'setup' function is one of the two standard Arduino sketch functions.
 * It's called when your keyboard first powers up. This is where you set up
 * Kaleidoscope and any plugins.
 */
void setup() {
  // First, call Kaleidoscope's internal setup function 
  Kaleidoscope.setup();
 
  // While we hope to improve this in the future, the NumPad plugin 
  // needs to be explicitly told which keymap layer is your numpad layer 
  NumPad.numPadLayer = NUMPAD;
 
  DakkarColorDark.activate();
 
  // To make the keymap editable without flashing new firmware, we store 
  // additional layers in EEPROM. For now, we reserve space for five layers. If 
  // one wants to use these layers, just set the default layer to one in EEPROM, 
  // by using the `settings.defaultLayer` Focus command, or by using the 
  // `keymap.onlyCustom` command to use EEPROM layers only. 
  EEPROMKeymap.setup(5);
}
 
/** loop is the second of the standard Arduino sketch functions.
  * As you might expect, it runs in a loop, never exiting.
  *
  * For Kaleidoscope-based keyboard firmware, you usually just want to
  * call Kaleidoscope.loop(); and not do anything custom here.
  */
 
void loop() {
  Kaleidoscope.loop();
}