added hold and toggle layer key functions

.gitignore

@@ -3,3 +3,5 @@
 .vscode/c_cpp_properties.json
 .vscode/launch.json
 .vscode/ipch
+
+src/config/wifi.h*

platformio.ini

@@ -16,4 +16,3 @@ lib_deps =
 	adafruit/Adafruit ST7735 and ST7789 Library@^1.9.3
 	paulstoffregen/Encoder@^1.4.2
 	adafruit/Adafruit NeoPixel@^1.10.5
-	adafruit/Adafruit TestBed@^1.3.0

src/config/config.cpp

@@ -1,10 +1,9 @@
 
 #include "config.hpp"
-
 #include "ditto.cpp"
-
 #include <Encoder.h>
 
+
 #define ENCODER_PIN_A 12
 #define ENCODER_PIN_B 13
 #define ROTARY_DIVIDER 4
@@ -17,69 +16,77 @@ enum custom_keys : keycode_t {
     KC_TOGGLE_BACKLIGHT,
 };
 
+usb_config_t usb_config() {
+    return {
+        .product_name = "Avant-Garde",
+        .manufacturer_name = "Flamingo.dev",
+        .serial_number = "0",
+    };
+}
+
 KEYMAP keymap(KEYMAP pref) {
     if(pref.size() != 0) return pref;
     return {
         {
-            KC_F13, KC_F14, KC_F15, 
-            ____, KC_F16, KC_F17
+            KC_PREV_TRACK, KC_PLAY_PAUSE, KC_NEXT_TRACK, 
+            ____, LCTRL(KC_Z), LCTRL(KC_Y)
         },
         {
-            KC_F18, KC_F19, KC_F20, 
-            ____, KC_F21, KC_F22
+            KC_F13, KC_F14, KC_F15, 
+            KC_F16, KC_F17, KC_F18
         },
         {
-            RCTRL(KC_F13), RCTRL(KC_F14), RCTRL(KC_F15),
-            ____, RCTRL(KC_F16), RCTRL(KC_F17) 
+            KC_F19, KC_F20, KC_F21, 
+            KC_F22, KC_F23, KC_F24
         },
         {
-            RCTRL(KC_F18), RCTRL(KC_F19), RCTRL(KC_F20),
-            ____, RCTRL(KC_F21), RCTRL(KC_F22)
+            LCTRL(KC_F13), LCTRL(KC_F14), LCTRL(KC_F15),
+            LCTRL(KC_F16), LCTRL(KC_F17), LCTRL(KC_F18),
         },
         {
-            KC_Q,   KC_W,   KC_E,   
-            ____, KC_R,   KC_LCTRL
+            LCTRL(KC_F19), LCTRL(KC_F20), LCTRL(KC_F21),
+            LCTRL(KC_F22), LCTRL(KC_F23), LCTRL(KC_F24),
         },
         {
-            KC_PREV_TRACK, KC_PLAY_PAUSE, KC_NEXT_TRACK, 
-            ____, LCTRL(KC_Z), LCTRL(KC_Y)
+            KC_Q, KC_W, KC_E,
+            KC_B, KC_R, KC_LCTRL,
         },
         {
             KC_TOGGLE_NEOPIXEL, KC_TOGGLE_LAYER_INFO, KC_TOGGLE_BACKLIGHT,
-            ____, ____, ____
+            ____, TAP(1), HOLD(2)
         }
     };
 }
 
 LAYER_NAMES layer_names(LAYER_NAMES pref) {
     if(pref.size() != 0) return pref;
     return {
-        "F13-F17", 
-        "F18-F22",
-        "CTL F13-F17",
-        "CTL F18-F22", 
-        "League", 
-        "Media",  
+        "Media",
+        "F13-F18", 
+        "F19-F24",
+        "CTL F13-F18",
+        "CTL F19-F24", 
+        "League",
         "Toggles"
     };
 }
 
 LAYER_COLORS layer_colors(LAYER_COLORS pref) {
     if(pref.size() != 0) return pref;
     return {
+        0xebeb54,
         0x7e2bcc, 
         0x7e2bcc, 
         0xd9276b, 
-        0xd9276b,
-        0xebeb54, 
-        0x2b2b2b,  
+        0xd9276b,  
+        0x2b7ecc,
         0x2b2b2b,
     };
 }
 
 bool neopixel_enabled = true;
 bool layerinfo_enabled = false;
-bool backlight_enabled = false;
+bool backlight_enabled = true;
 
 void task_user_keycode_custom(event_t event) {
     switch(event.keydata.key) {
@@ -100,8 +107,11 @@ void task_user_keycode_custom(event_t event) {
 };
 
 void task_user_encoder_tick(event_t event) {
-    uint8_t encoder_value = encoder.read();
-    uint8_t layer_change = (encoder_value / ROTARY_DIVIDER) % event.layer_count;
+    int8_t encoder_value = encoder.read();
+    if (encoder_value < 0) {
+        encoder_value = (event.layer_count * 10) - encoder_value;
+    }
+    int8_t layer_change = (encoder_value / ROTARY_DIVIDER) % event.layer_count;
     (*event.layer) = layer_change;
 }
 
@@ -123,11 +133,9 @@ void task_user_display_tick(event_t event) {
         canvas->println("{L: " + String((*event.layer), DEC) + ", R: " + String(encoder_value, DEC) + " }");
     }
 
-
     canvas->setCursor(0, DISPLAY_HEIGHT - 24);
     canvas->setTextSize(3);
     canvas->println(event.methods.get_layer_name(*event.layer));
-
     canvas->drawBitmap(0, 0, ditto_bitmap[current_frame], 135, 135, 0xffff);
 
     if(neopixel_enabled) {
@@ -139,7 +147,7 @@ void task_user_display_tick(event_t event) {
 
 void task_user_animation_frame(event_t event) {
     current_frame += 1;
-    if(current_frame >= DITTO_FRAMES) {
+    if(current_frame >= FRAMES) {
         current_frame = 0;
     }
 }

src/config/config.hpp

@@ -22,5 +22,9 @@
 #define DISPLAY_ENABLED
 #define WEBSITE_ENABLED
 
-#define NETWORK_SSID ""
-#define NETWORK_PASS ""
+#include "./wifi.hpp"
+
+#define NETWORK_ENABLED
+
+#define NETWORK_SSID WIFI_SSID
+#define NETWORK_PASS WIFI_PASS

src/internal/graphics/graphics.cpp

@@ -20,7 +20,6 @@ void gfx_init() {
 
     tft.init(DISPLAY_WIDTH, DISPLAY_HEIGHT);
     tft.setRotation(DISPLAY_ROTATION);
-    tft.setRotation(2);
 
     #ifdef NEOPIXEL_ENABLED
         neopixel.begin();

src/internal/keycode/handler.cpp

@@ -23,6 +23,12 @@ byte previous_state = 0;
 KeyReport report;
 
 void usb_init() {
+    usb_config_t config = usb_config();
+
+    USB.manufacturerName(config.manufacturer_name.c_str());
+    USB.productName(config.product_name.c_str());
+    USB.serialNumber(config.serial_number.c_str());
+
     consumer.begin();
     keyboard.begin();
     USB.begin();
@@ -58,6 +64,7 @@ void handle_user_tasks() {
 }
 
 std::vector<keydata_t> keystates = {};
+int8_t tap_layer = -1; // just hardcode taplayers for now since its much easier than having an event array for it
 
 int16_t has_keystate(uint8_t key_id) {
     std::vector<keydata_t>::iterator i = keystates.begin();
@@ -103,6 +110,7 @@ void handle_state(byte state, uint16_t size) {
                 keycode,
                 (keycode_type_t)type,
                 i,
+                layer,
             };
             event.keydata = keydata;
         }
@@ -123,8 +131,6 @@ void flush() {
 }
 
 void handle_event(event_t event) {
-    // if(task_user_keycode(event)) return;
-
     if(event.type == EVENT_KEY_DOWN) keystates.push_back(event.keydata);
 
     switch(event.keydata.type) {
@@ -139,6 +145,8 @@ void handle_event(event_t event) {
                     if(HAS_MOD(event.keydata.key)) release_raw(MOD(event.keydata.key));
                     break;
             }
+            break;
+
         case T_MOD:
             switch(event.type) {
                 case EVENT_KEY_DOWN:
@@ -149,6 +157,7 @@ void handle_event(event_t event) {
                     break;
             }
             break;
+
         case T_MEDIA:
             switch(event.type) {
                 case EVENT_KEY_DOWN:
@@ -159,25 +168,70 @@ void handle_event(event_t event) {
                     break;
             }
             break;
+
         case T_LAYER_HOLD:
-            // if(!task_user_keycode_layer_hold(event)) break;
-        case T_LAYER_SWAP:
-            // if(!task_user_keycode_layer_swap(event)) break;
+            switch(event.type) {
+                case EVENT_KEY_DOWN:
+                    (*event.layer) = event.keydata.keycode;
+                    return; // prevent release event to be called
+                case EVENT_KEY_UP:
+                    (*event.layer) = event.keydata.layer;
+                    return; // prevent release event to be called
+            }
+            break;
+
+        case T_LAYER_TAP:
+            switch(event.type) {
+                case EVENT_KEY_DOWN:
+                    (*event.layer) = event.keydata.keycode;
+                    tap_layer = event.keydata.layer;
+                case EVENT_KEY_UP:
+                    return; // prevent release event to be called
+            }
+            break;
+
         case T_LAYER_TOGL:
-            // if(!task_user_keycode_layer_toggle(event)) break;
+            switch(event.type) {
+                case EVENT_KEY_DOWN:
+                    (*event.layer) = event.keydata.keycode;
+                    return; // prevent release event to be called
+            }
+            break;
 
         case T_CUSTOM:
             task_user_keycode_custom(event);
             break;
     }
+
+    // switch(event.type) {
+    //     case EVENT_KEY_DOWN:
+    //         onpress(event);
+    //         break;
+    //     case EVENT_KEY_UP:
+    //         onrelease(event);
+    //         break;
+    // }
+}
+
+void onpress(event_t e) {
+    task_user_onpress(e);
+}
+
+void onrelease(event_t e) {
+    if(tap_layer >= 0) {
+        (*e.layer) = tap_layer;
+        tap_layer = -1;
+    }
+
+    task_user_onrelease(e);
 }
 
 void press(uint16_t keycode) {
     uint8_t type = keycode >> 8;
     uint8_t code = keycode;
 
     keydata_t keydata = {code, keycode_type_t(type)};
-    event_t event = {EVENT_KEY_DOWN, keydata, &layer, keymap({}).size(), methods};
+    event_t event = {EVENT_KEY_DOWN, keydata, &layer, uint8_t(keymap({}).size()), methods};
 
     handle_event(event);
 }
@@ -187,7 +241,7 @@ void release(uint16_t keycode) {
     uint8_t code = keycode;
 
     keydata_t keydata = {code, keycode_type_t(type)};
-    event_t event = {EVENT_KEY_UP, keydata, &layer, keymap({}).size(), methods};
+    event_t event = {EVENT_KEY_UP, keydata, &layer, uint8_t(keymap({}).size()), methods};
 
     handle_event(event);
 }

src/internal/keycode/handler.hpp

@@ -18,6 +18,8 @@ int16_t has_keystate(uint8_t key_id);
 void handle_state(byte state, uint16_t size);
 void handle_event(event_t event);
 void flush();
+void onpress(event_t event);
+void onrelease(event_t event);
 void press(uint16_t keycode);
 void release(uint16_t keycode);
 void press_raw(uint8_t keycode);

src/internal/keycode/keycodes.hpp

@@ -10,7 +10,7 @@ enum keycode_type_t : uint8_t {
     T_MEDIA             = 0x2,
     T_LAYER_TOGL        = 0x3,
     T_LAYER_HOLD        = 0x4,
-    T_LAYER_SWAP        = 0x5,
+    T_LAYER_TAP         = 0x5,
     //... place for 9 more types
     //    after that, probably need to update to uint16_t
     T_CUSTOM            = 0xF,
@@ -19,8 +19,8 @@ enum keycode_type_t : uint8_t {
 #define KC(code, type) ((type << 12) | code)
 
 #define HOLD(code) KC(code, T_LAYER_HOLD)
-#define TOGL(code) KC(code, T_LAYER_TOGGLE)
-#define TO(code) KC(code, T_LAYER_SWAP)
+#define TO(code) KC(code, T_LAYER_TOGGLE)
+#define TAP(code) KC(code, T_LAYER_TAP)
 
 #define KC_CUSTOM KC(0, T_CUSTOM)
 
@@ -31,6 +31,7 @@ struct keydata_t {
     uint8_t keycode;
     keycode_type_t type;
     uint16_t key_id;
+    uint8_t layer;
 };
 
 struct methods_t {
@@ -78,11 +79,21 @@ typedef std::vector<uint32_t> LAYER_COLORS;
 /** weaks **/
 
 void task_user_keycode(event_t event) __attribute__ ((weak));
+void task_user_onrelease(event_t event) __attribute__ ((weak));
+void task_user_onpress(event_t event) __attribute__ ((weak));
 void task_user_keycode_custom(event_t event) __attribute__ ((weak));
 void task_user_encoder_tick(event_t event) __attribute__ ((weak));
 void task_user_display_tick(event_t event) __attribute__ ((weak));
 void task_user_animation_frame(event_t event) __attribute__ ((weak));
 
+struct usb_config_t {
+    String product_name;
+    String manufacturer_name;
+    String serial_number;
+};
+
+usb_config_t usb_config() __attribute__ ((weak));
+
 KEYMAP keymap(KEYMAP pref) __attribute__ ((weak));
 LAYER_NAMES layer_names(LAYER_NAMES pref) __attribute__ ((weak));
 LAYER_COLORS layer_colors(LAYER_COLORS pref) __attribute__ ((weak));

src/main.cpp

@@ -44,9 +44,9 @@ void setup() {
 }
 
 void loop() {
-    thread_matrix = std::thread(matrix_loop);
     thread_user_tasks = std::thread(user_tasks_loop);
+    thread_matrix = std::thread(matrix_loop);
 
-    thread_matrix.join();
     thread_user_tasks.join();
+    thread_matrix.join();
 }