Various improvements for the AnnePro2 (#16579)

keyboards/annepro2/annepro2.c

@@ -24,7 +24,7 @@
 #define RAM_MAGIC_LOCATION 0x20001ffc
 #define IAP_MAGIC_VALUE 0x0000fab2
 
-static const SerialConfig ledUartInitConfig = {
+static const SerialConfig led_uart_init_config = {
     .speed = 115200,
 };
 
@@ -32,21 +32,25 @@ static const SerialConfig ledUartInitConfig = {
 #    define LED_UART_BAUD_RATE 115200
 #endif  // LED_UART_BAUD_RATE
 
-static const SerialConfig ledUartRuntimeConfig = {
+static const SerialConfig led_uart_runtine_config = {
     .speed = LED_UART_BAUD_RATE,
 };
 
-static const SerialConfig bleUartConfig = {
+static const SerialConfig ble_uart_config = {
     .speed = 115200,
 };
 
-static uint8_t ledMcuWakeup[11] = {0x7b, 0x10, 0x43, 0x10, 0x03, 0x00, 0x00, 0x7d, 0x02, 0x01, 0x02};
+static uint8_t led_mcu_wakeup[11] = {0x7b, 0x10, 0x43, 0x10, 0x03, 0x00, 0x00, 0x7d, 0x02, 0x01, 0x02};
 
-ble_capslock_t BLECapsLock = {._dummy = {0}, .caps_lock = false};
+ble_capslock_t ble_capslock = {._dummy = {0}, .caps_lock = false};
+
+#ifdef RGB_MATRIX_ENABLE
+static uint8_t current_rgb_row = 0;
+#endif
 
 void bootloader_jump(void) {
     // Send msg to shine to boot into IAP
-    annepro2SetIAP();
+    ap2_set_IAP();
 
     // wait for shine to boot into IAP
     wait_ms(15);
@@ -67,27 +71,27 @@ void bootloader_jump(void) {
 
 void keyboard_pre_init_kb(void) {
     // Start LED UART
-    sdStart(&SD0, &ledUartInitConfig);
+    sdStart(&SD0, &led_uart_init_config);
     /* Let the LED chip settle a bit before switching the mode.
      * That helped at least one person. */
     wait_ms(15);
-    sdWrite(&SD0, ledMcuWakeup, sizeof(ledMcuWakeup));
+    sdWrite(&SD0, led_mcu_wakeup, sizeof(led_mcu_wakeup));
 
     // wait to receive response from wakeup
     wait_ms(15);
 
-    protoInit(&proto, ledCommandCallback);
+    proto_init(&proto, led_command_callback);
 
     // loop to clear out receive buffer from shine wakeup
     while (!sdGetWouldBlock(&SD0)) sdGet(&SD0);
 
-    sdStart(&SD0, &ledUartRuntimeConfig);
+    sdStart(&SD0, &led_uart_runtine_config);
     keyboard_pre_init_user();
 }
 
 void keyboard_post_init_kb(void) {
     // Start BLE UART
-    sdStart(&SD1, &bleUartConfig);
+    sdStart(&SD1, &ble_uart_config);
     annepro2_ble_startup();
 
     // Give the send uart thread some time to
@@ -97,7 +101,11 @@ void keyboard_post_init_kb(void) {
     // loop to clear out receive buffer from ble wakeup
     while (!sdGetWouldBlock(&SD1)) sdGet(&SD1);
 
-    annepro2LedGetStatus();
+    ap2_led_get_status();
+
+    #ifdef RGB_MATRIX_ENABLE
+    ap2_led_enable();
+    #endif
 
     keyboard_post_init_user();
 }
@@ -106,25 +114,35 @@ void matrix_scan_kb() {
     // if there's stuff on the ble serial buffer
     // read it into the capslock struct
     while (!sdGetWouldBlock(&SD1)) {
-        sdReadTimeout(&SD1, (uint8_t *)&BLECapsLock, sizeof(ble_capslock_t), 10);
+        sdReadTimeout(&SD1, (uint8_t *)&ble_capslock, sizeof(ble_capslock_t), 10);
     }
 
     /* While there's data from LED keyboard sent - read it. */
     while (!sdGetWouldBlock(&SD0)) {
         uint8_t byte = sdGet(&SD0);
-        protoConsume(&proto, byte);
+        proto_consume(&proto, byte);
+    }
+
+    #ifdef RGB_MATRIX_ENABLE
+    /* If there's data ready to be sent to LED MCU - send it. */
+    if(rgb_row_changed[current_rgb_row])
+    {
+        rgb_row_changed[current_rgb_row] = 0;
+        ap2_led_mask_set_row(current_rgb_row);
     }
+    current_rgb_row = (current_rgb_row + 1) % NUM_ROW;
+    #endif
 
     matrix_scan_user();
 }
 
 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
     if (record->event.pressed) {
-        if (annepro2LedStatus.matrixEnabled && annepro2LedStatus.isReactive) {
-            annepro2LedForwardKeypress(record->event.key.row, record->event.key.col);
+        if (ap2_led_status.matrix_enabled && ap2_led_status.is_reactive) {
+            ap2_led_forward_keypress(record->event.key.row, record->event.key.col);
         }
 
-        const annepro2Led_t blue = {
+        const ap2_led_t blue = {
             .p.blue  = 0xff,
             .p.red   = 0x00,
             .p.green = 0x00,
@@ -135,22 +153,22 @@ bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
             case KC_AP2_BT1:
                 annepro2_ble_broadcast(0);
                 /* FIXME: This hardcodes col/row position */
-                annepro2LedBlink(0, 1, blue, 8, 50);
+                ap2_led_blink(0, 1, blue, 8, 50);
                 return false;
 
             case KC_AP2_BT2:
                 annepro2_ble_broadcast(1);
-                annepro2LedBlink(0, 2, blue, 8, 50);
+                ap2_led_blink(0, 2, blue, 8, 50);
                 return false;
 
             case KC_AP2_BT3:
                 annepro2_ble_broadcast(2);
-                annepro2LedBlink(0, 3, blue, 8, 50);
+                ap2_led_blink(0, 3, blue, 8, 50);
                 return false;
 
             case KC_AP2_BT4:
                 annepro2_ble_broadcast(3);
-                annepro2LedBlink(0, 4, blue, 8, 50);
+                ap2_led_blink(0, 4, blue, 8, 50);
                 return false;
 
             case KC_AP2_USB:
@@ -162,37 +180,43 @@ bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
                 return false;
 
             case KC_AP_LED_OFF:
-                annepro2LedDisable();
+                ap2_led_disable();
                 break;
 
             case KC_AP_LED_ON:
-                if (annepro2LedStatus.matrixEnabled) {
-                    annepro2LedNextProfile();
+                if (ap2_led_status.matrix_enabled) {
+                    ap2_led_next_profile();
                 } else {
-                    annepro2LedEnable();
+                    ap2_led_enable();
                 }
-                annepro2LedResetForegroundColor();
+                ap2_led_reset_foreground_color();
                 break;
 
             case KC_AP_LED_NEXT_PROFILE:
-                annepro2LedNextProfile();
-                annepro2LedResetForegroundColor();
+                ap2_led_next_profile();
+                ap2_led_reset_foreground_color();
                 break;
 
             case KC_AP_LED_PREV_PROFILE:
-                annepro2LedPrevProfile();
-                annepro2LedResetForegroundColor();
+                ap2_led_prev_profile();
+                ap2_led_reset_foreground_color();
                 break;
 
             case KC_AP_LED_NEXT_INTENSITY:
-                annepro2LedNextIntensity();
-                annepro2LedResetForegroundColor();
+                ap2_led_next_intensity();
+                ap2_led_reset_foreground_color();
                 return false;
 
             case KC_AP_LED_SPEED:
-                annepro2LedNextAnimationSpeed();
-                annepro2LedResetForegroundColor();
+                ap2_led_next_animation_speed();
+                ap2_led_reset_foreground_color();
                 return false;
+            #ifdef RGB_MATRIX_ENABLE
+            case RGB_TOG:
+                if(rgb_matrix_is_enabled()) ap2_led_disable();
+                else ap2_led_enable();
+                return true;
+            #endif
 
             default:
                 break;

keyboards/annepro2/annepro2.h

@@ -24,16 +24,16 @@ typedef struct __attribute__((__packed__)) {
     uint8_t _dummy[10];
     bool    caps_lock;
 } ble_capslock_t;
-extern ble_capslock_t BLECapsLock;
+extern ble_capslock_t ble_capslock;
 
 // Matrix keymap
 // clang-format off
-#define LAYOUT( \
+#define LAYOUT_60_ansi( \
     K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \
     K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, \
     K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C,      \
     K30,      K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C,      \
-    K40, K42, K43,                K46,           K49,  K4A,   K4B,   K4C  \
+    K40, K42, K43,                K46,           K49, K4A, K4B, K4C       \
 ) { \
     /*            COL1   COL2   COL3   COL4   COL5   COL6   COL7   COL8   COL9   COL10  COL11  COL12  COL13  COL14*/ \
     /* ROW1  */ { K00,   K01,   K02,   K03,   K04,   K05,   K06,   K07,   K08,   K09,   K0A,   K0B,   K0C,   K0D  }, \

keyboards/annepro2/annepro2_ble.c

@@ -35,47 +35,47 @@ static host_driver_t ap2_ble_driver = {
     ap2_ble_leds, ap2_ble_keyboard, ap2_ble_mouse, ap2_ble_system, ap2_ble_consumer,
 };
 
-static uint8_t bleMcuWakeup[11] = {0x7b, 0x12, 0x53, 0x00, 0x03, 0x00, 0x01, 0x7d, 0x02, 0x01, 0x02};
+static uint8_t ble_mcu_wakeup[11] = {0x7b, 0x12, 0x53, 0x00, 0x03, 0x00, 0x01, 0x7d, 0x02, 0x01, 0x02};
 
-static uint8_t bleMcuStartBroadcast[11] = {
+static uint8_t ble_mcu_start_broadcast[11] = {
     0x7b, 0x12, 0x53, 0x00, 0x03, 0x00, 0x00, 0x7d, 0x40, 0x01, 0x00  // Broadcast ID[0-3]
 };
 
-static uint8_t bleMcuConnect[11] = {
+static uint8_t ble_mcu_connect[11] = {
     0x7b, 0x12, 0x53, 0x00, 0x03, 0x00, 0x00, 0x7d, 0x40, 0x04, 0x00  // Connect ID [0-3]
 };
 
-static uint8_t bleMcuSendReport[10] = {
+static uint8_t ble_mcu_send_report[10] = {
     0x7b, 0x12, 0x53, 0x00, 0x0A, 0x00, 0x00, 0x7d, 0x10, 0x04,
 };
 
-static uint8_t bleMcuSendConsumerReport[10] = {
+static uint8_t ble_mcu_send_consumer_report[10] = {
     0x7b, 0x12, 0x53, 0x00, 0x06, 0x00, 0x00, 0x7d, 0x10, 0x08,
 };
 
-static uint8_t bleMcuUnpair[10] = {
+static uint8_t ble_mcu_unpair[10] = {
     0x7b, 0x12, 0x53, 0x00, 0x02, 0x00, 0x00, 0x7d, 0x40, 0x05,
 };
 
-static uint8_t bleMcuBootload[11] = {0x7b, 0x10, 0x51, 0x10, 0x03, 0x00, 0x00, 0x7d, 0x02, 0x01, 0x01};
+static uint8_t ble_mcu_bootload[11] = {0x7b, 0x10, 0x51, 0x10, 0x03, 0x00, 0x00, 0x7d, 0x02, 0x01, 0x01};
 
-static host_driver_t *lastHostDriver = NULL;
+static host_driver_t *last_host_driver = NULL;
 #ifdef NKRO_ENABLE
 static bool lastNkroStatus = false;
 #endif  // NKRO_ENABLE
 
 /* -------------------- Public Function Implementation ---------------------- */
 
-void annepro2_ble_bootload(void) { sdWrite(&SD1, bleMcuBootload, sizeof(bleMcuBootload)); }
+void annepro2_ble_bootload(void) { sdWrite(&SD1, ble_mcu_bootload, sizeof(ble_mcu_bootload)); }
 
-void annepro2_ble_startup(void) { sdWrite(&SD1, bleMcuWakeup, sizeof(bleMcuWakeup)); }
+void annepro2_ble_startup(void) { sdWrite(&SD1, ble_mcu_wakeup, sizeof(ble_mcu_wakeup)); }
 
 void annepro2_ble_broadcast(uint8_t port) {
     if (port > 3) {
         port = 3;
     }
     // sdPut(&SD1, 0x00);
-    sdWrite(&SD1, bleMcuStartBroadcast, sizeof(bleMcuStartBroadcast));
+    sdWrite(&SD1, ble_mcu_start_broadcast, sizeof(ble_mcu_start_broadcast));
     sdPut(&SD1, port);
     static int lastBroadcast = -1;
     if (lastBroadcast == port) {
@@ -88,7 +88,7 @@ void annepro2_ble_connect(uint8_t port) {
     if (port > 3) {
         port = 3;
     }
-    sdWrite(&SD1, bleMcuConnect, sizeof(bleMcuConnect));
+    sdWrite(&SD1, ble_mcu_connect, sizeof(ble_mcu_connect));
     sdPut(&SD1, port);
     ap2_ble_swtich_ble_driver();
 }
@@ -103,12 +103,12 @@ void annepro2_ble_disconnect(void) {
 #ifdef NKRO_ENABLE
     keymap_config.nkro = lastNkroStatus;
 #endif
-    host_set_driver(lastHostDriver);
+    host_set_driver(last_host_driver);
 }
 
 void annepro2_ble_unpair(void) {
     // sdPut(&SD1, 0x0);
-    sdWrite(&SD1, bleMcuUnpair, sizeof(bleMcuUnpair));
+    sdWrite(&SD1, ble_mcu_unpair, sizeof(ble_mcu_unpair));
 }
 
 /* ------------------- Static Function Implementation ----------------------- */
@@ -117,7 +117,7 @@ static void ap2_ble_swtich_ble_driver(void) {
         return;
     }
     clear_keyboard();
-    lastHostDriver = host_get_driver();
+    last_host_driver = host_get_driver();
 #ifdef NKRO_ENABLE
     lastNkroStatus = keymap_config.nkro;
 #endif
@@ -154,7 +154,7 @@ static inline uint16_t CONSUMER2AP2(uint16_t usage) {
 
 static void ap2_ble_consumer(uint16_t data) {
     sdPut(&SD1, 0x0);
-    sdWrite(&SD1, bleMcuSendConsumerReport, sizeof(bleMcuSendConsumerReport));
+    sdWrite(&SD1, ble_mcu_send_consumer_report, sizeof(ble_mcu_send_consumer_report));
     sdPut(&SD1, CONSUMER2AP2(data));
     static const uint8_t dummy[3] = {0};
     sdWrite(&SD1, dummy, sizeof(dummy));
@@ -165,6 +165,6 @@ static void ap2_ble_consumer(uint16_t data) {
  */
 static void ap2_ble_keyboard(report_keyboard_t *report) {
     sdPut(&SD1, 0x0);
-    sdWrite(&SD1, bleMcuSendReport, sizeof(bleMcuSendReport));
+    sdWrite(&SD1, ble_mcu_send_report, sizeof(ble_mcu_send_report));
     sdWrite(&SD1, &report->raw[0], KEYBOARD_REPORT_SIZE);
 }

keyboards/annepro2/ap2_led.c

@@ -21,28 +21,29 @@
 #include "ap2_led.h"
 #include "protocol.h"
 
-annepro2Led_t       ledMask[KEY_COUNT];
-annepro2LedStatus_t annepro2LedStatus;
+ap2_led_t       led_mask[KEY_COUNT];
+ap2_led_status_t ap2_led_status;
+uint8_t rgb_row_changed[NUM_ROW];
 
-void ledCommandCallback(const message_t *msg) {
+void led_command_callback(const message_t *msg) {
     switch (msg->command) {
         case CMD_LED_STATUS:
-            annepro2LedStatus.amountOfProfiles = msg->payload[0];
-            annepro2LedStatus.currentProfile   = msg->payload[1];
-            annepro2LedStatus.matrixEnabled    = msg->payload[2];
-            annepro2LedStatus.isReactive       = msg->payload[3];
-            annepro2LedStatus.ledIntensity     = msg->payload[4];
-            annepro2LedStatus.errors           = msg->payload[5];
+            ap2_led_status.amount_of_profiles = msg->payload[0];
+            ap2_led_status.current_profile    = msg->payload[1];
+            ap2_led_status.matrix_enabled     = msg->payload[2];
+            ap2_led_status.is_reactive        = msg->payload[3];
+            ap2_led_status.led_intensity      = msg->payload[4];
+            ap2_led_status.errors             = msg->payload[5];
             break;
 
 #ifdef CONSOLE_ENABLE
         case CMD_LED_DEBUG:
             /* TODO: Don't use printf. */
             printf("LED:");
-            for (int i = 0; i < msg->payloadSize; i++) {
+            for (int i = 0; i < msg->payload_size; i++) {
                 printf("%02x ", msg->payload[i]);
             }
-            for (int i = 0; i < msg->payloadSize; i++) {
+            for (int i = 0; i < msg->payload_size; i++) {
                 printf("%c", msg->payload[i]);
             }
             printf("\n");
@@ -51,63 +52,63 @@ void ledCommandCallback(const message_t *msg) {
     }
 }
 
-void annepro2SetIAP(void) { protoTx(CMD_LED_IAP, NULL, 0, 3); }
+void ap2_set_IAP(void) { proto_tx(CMD_LED_IAP, NULL, 0, 3); }
 
-void annepro2LedDisable(void) { protoTx(CMD_LED_OFF, NULL, 0, 3); }
+void ap2_led_disable(void) { proto_tx(CMD_LED_OFF, NULL, 0, 3); }
 
-void annepro2LedEnable(void) { protoTx(CMD_LED_ON, NULL, 0, 3); }
+void ap2_led_enable(void) { proto_tx(CMD_LED_ON, NULL, 0, 3); }
 
-void annepro2LedSetProfile(uint8_t prof) { protoTx(CMD_LED_SET_PROFILE, &prof, sizeof(prof), 3); }
+void ap2_led_set_profile(uint8_t prof) { proto_tx(CMD_LED_SET_PROFILE, &prof, sizeof(prof), 3); }
 
-void annepro2LedGetStatus() { protoTx(CMD_LED_GET_STATUS, NULL, 0, 3); }
+void ap2_led_get_status() { proto_tx(CMD_LED_GET_STATUS, NULL, 0, 3); }
 
-void annepro2LedNextProfile() { protoTx(CMD_LED_NEXT_PROFILE, NULL, 0, 3); }
+void ap2_led_next_profile() { proto_tx(CMD_LED_NEXT_PROFILE, NULL, 0, 3); }
 
-void annepro2LedNextIntensity() { protoTx(CMD_LED_NEXT_INTENSITY, NULL, 0, 3); }
+void ap2_led_next_intensity() { proto_tx(CMD_LED_NEXT_INTENSITY, NULL, 0, 3); }
 
-void annepro2LedNextAnimationSpeed() { protoTx(CMD_LED_NEXT_ANIMATION_SPEED, NULL, 0, 3); }
+void ap2_led_next_animation_speed() { proto_tx(CMD_LED_NEXT_ANIMATION_SPEED, NULL, 0, 3); }
 
-void annepro2LedPrevProfile() { protoTx(CMD_LED_PREV_PROFILE, NULL, 0, 3); }
+void ap2_led_prev_profile() { proto_tx(CMD_LED_PREV_PROFILE, NULL, 0, 3); }
 
-void annepro2LedMaskSetKey(uint8_t row, uint8_t col, annepro2Led_t color) {
+void ap2_led_mask_set_key(uint8_t row, uint8_t col, ap2_led_t color) {
     uint8_t payload[] = {row, col, color.p.blue, color.p.green, color.p.red, color.p.alpha};
-    protoTx(CMD_LED_MASK_SET_KEY, payload, sizeof(payload), 1);
+    proto_tx(CMD_LED_MASK_SET_KEY, payload, sizeof(payload), 1);
 }
 
 /* Push a whole local row to the shine */
-void annepro2LedMaskSetRow(uint8_t row) {
-    uint8_t payload[NUM_COLUMN * sizeof(annepro2Led_t) + 1];
+void ap2_led_mask_set_row(uint8_t row) {
+    uint8_t payload[NUM_COLUMN * sizeof(ap2_led_t) + 1];
     payload[0] = row;
-    memcpy(payload + 1, &ledMask[ROWCOL2IDX(row, 0)], sizeof(*ledMask) * NUM_COLUMN);
-    protoTx(CMD_LED_MASK_SET_ROW, payload, sizeof(payload), 1);
+    memcpy(payload + 1, &led_mask[ROWCOL2IDX(row, 0)], sizeof(*led_mask) * NUM_COLUMN);
+    proto_tx(CMD_LED_MASK_SET_ROW, payload, sizeof(payload), 1);
 }
 
 /* Synchronize all rows */
-void annepro2LedMaskSetAll(void) {
-    for (int row = 0; row < 5; row++) annepro2LedMaskSetRow(row);
+void ap2_led_mask_set_all(void) {
+    for (int row = 0; row < 5; row++) ap2_led_mask_set_row(row);
 }
 
 /* Set all keys to a given color */
-void annepro2LedMaskSetMono(const annepro2Led_t color) { protoTx(CMD_LED_MASK_SET_MONO, (uint8_t *)&color, sizeof(color), 1); }
+void ap2_led_mask_set_mono(const ap2_led_t color) { proto_tx(CMD_LED_MASK_SET_MONO, (uint8_t *)&color, sizeof(color), 1); }
 
-void annepro2LedBlink(uint8_t row, uint8_t col, annepro2Led_t color, uint8_t count, uint8_t hundredths) {
+void ap2_led_blink(uint8_t row, uint8_t col, ap2_led_t color, uint8_t count, uint8_t hundredths) {
     uint8_t payload[] = {row, col, color.p.blue, color.p.green, color.p.red, color.p.alpha, count, hundredths};
-    protoTx(CMD_LED_KEY_BLINK, payload, sizeof(payload), 1);
+    proto_tx(CMD_LED_KEY_BLINK, payload, sizeof(payload), 1);
 }
 
-void annepro2LedSetForegroundColor(uint8_t red, uint8_t green, uint8_t blue) {
-    annepro2Led_t color = {.p.red = red, .p.green = green, .p.blue = blue, .p.alpha = 0xff};
-    annepro2LedMaskSetMono(color);
+void ap2_led_set_foreground_color(uint8_t red, uint8_t green, uint8_t blue) {
+    ap2_led_t color = {.p.red = red, .p.green = green, .p.blue = blue, .p.alpha = 0xff};
+    ap2_led_mask_set_mono(color);
 }
 
-void annepro2LedResetForegroundColor() {
-    annepro2Led_t color = {
+void ap2_led_reset_foreground_color() {
+    ap2_led_t color = {
         .p.red   = 0,
         .p.green = 0,
         .p.blue  = 0,
         .p.alpha = 0,
     };
-    annepro2LedMaskSetMono(color);
+    ap2_led_mask_set_mono(color);
 }
 
 /*
@@ -128,7 +129,7 @@ void annepro2LedResetForegroundColor() {
  * Following it are 3 bits of row and 4 bits of col.
  * 1 + 3 + 4 = 8 bits - only a single byte is sent for every keypress.
  */
-void annepro2LedForwardKeypress(uint8_t row, uint8_t col) {
+void ap2_led_forward_keypress(uint8_t row, uint8_t col) {
     const uint8_t payload = row << 4 | col;
-    protoTx(CMD_LED_KEY_DOWN, &payload, 1, 1);
+    proto_tx(CMD_LED_KEY_DOWN, &payload, 1, 1);
 }

keyboards/annepro2/ap2_led.h

@@ -1,18 +1,18 @@
  /* Copyright 2021 OpenAnnePro community
-  * 
-  * This program is free software: you can redistribute it and/or modify 
-  * it under the terms of the GNU General Public License as published by 
-  * the Free Software Foundation, either version 2 of the License, or 
-  * (at your option) any later version. 
-  * 
-  * This program is distributed in the hope that it will be useful, 
-  * but WITHOUT ANY WARRANTY; without even the implied warranty of 
-  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
-  * GNU General Public License for more details. 
-  * 
-  * You should have received a copy of the GNU General Public License 
-  * along with this program.  If not, see <http://www.gnu.org/licenses/>. 
-  */ 
+  *
+  * This program is free software: you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation, either version 2 of the License, or
+  * (at your option) any later version.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  */
 
 #pragma once
 
@@ -31,54 +31,63 @@ typedef union {
     uint8_t pv[4];
     /* 0xrgb in mem is b g r a */
     uint32_t rgb;
-} annepro2Led_t;
+} ap2_led_t;
 
 #define ROWCOL2IDX(row, col) (NUM_COLUMN * (row) + (col))
 #define NUM_COLUMN 14
 #define NUM_ROW 5
 #define KEY_COUNT 70
 
-/* Local copy of ledMask, used to override colors on the board */
-extern annepro2Led_t ledMask[KEY_COUNT];
+/* Local copy of led_mask, used to override colors on the board */
+extern ap2_led_t led_mask[KEY_COUNT];
+extern uint8_t rgb_row_changed[NUM_ROW];
 
 /* Handle incoming messages */
-extern void ledCommandCallback(const message_t *msg);
+extern void led_command_callback(const message_t *msg);
 
-void annepro2SetIAP(void);
-void annepro2LedDisable(void);
-void annepro2LedEnable(void);
-void annepro2LedSetProfile(uint8_t prof);
-void annepro2LedGetStatus(void);
-void annepro2LedNextProfile(void);
-void annepro2LedPrevProfile(void);
-void annepro2LedNextIntensity(void);
-void annepro2LedNextAnimationSpeed(void);
-void annepro2LedForwardKeypress(uint8_t row, uint8_t col);
+void ap2_set_IAP(void);
+void ap2_led_disable(void);
+void ap2_led_enable(void);
+void ap2_led_set_profile(uint8_t prof);
+void ap2_led_get_status(void);
+void ap2_led_next_profile(void);
+void ap2_led_prev_profile(void);
+void ap2_led_next_intensity(void);
+void ap2_led_next_animation_speed(void);
+void ap2_led_forward_keypress(uint8_t row, uint8_t col);
 
 /* Set single key to a given color; alpha controls which is displayed */
-void annepro2LedMaskSetKey(uint8_t row, uint8_t col, annepro2Led_t color);
+void ap2_led_mask_set_key(uint8_t row, uint8_t col, ap2_led_t color);
 /* Push a whole local row to the shine */
-void annepro2LedMaskSetRow(uint8_t row);
+void ap2_led_mask_set_row(uint8_t row);
 /* Synchronize all rows */
-void annepro2LedMaskSetAll(void);
+void ap2_led_mask_set_all(void);
 
 /* Set all keys to a given color */
-void annepro2LedMaskSetMono(annepro2Led_t color);
+void ap2_led_mask_set_mono(ap2_led_t color);
 
 /* Blink given key `count` times by masking it with a `color`. Blink takes `hundredths` of a second */
-void annepro2LedBlink(uint8_t row, uint8_t col, annepro2Led_t color, uint8_t count, uint8_t hundredths);
+void ap2_led_blink(uint8_t row, uint8_t col, ap2_led_t color, uint8_t count, uint8_t hundredths);
 
 /* Kept for compatibility, but implemented using masks */
-void annepro2LedSetForegroundColor(uint8_t red, uint8_t green, uint8_t blue);
-void annepro2LedResetForegroundColor(void);
+void ap2_led_set_foreground_color(uint8_t red, uint8_t green, uint8_t blue);
+void ap2_led_reset_foreground_color(void);
 
 typedef struct {
-    uint8_t amountOfProfiles;
-    uint8_t currentProfile;
-    uint8_t matrixEnabled;
-    uint8_t isReactive;
-    uint8_t ledIntensity;
+    uint8_t amount_of_profiles;
+    uint8_t current_profile;
+    uint8_t matrix_enabled;
+    uint8_t is_reactive;
+    uint8_t led_intensity;
     uint8_t errors;
-} annepro2LedStatus_t;
+} ap2_led_status_t;
 
-extern annepro2LedStatus_t annepro2LedStatus;
+extern ap2_led_status_t ap2_led_status;
+
+#ifdef RGB_MATRIX_ENABLE
+/* RGB driver functions */
+void init(void);
+void flush(void);
+void set_color(int index, uint8_t r, uint8_t g, uint8_t b);
+void set_color_all(uint8_t r, uint8_t g, uint8_t b);
+#endif

keyboards/annepro2/c15/config.h

@@ -18,6 +18,7 @@
 #pragma once
 
 #include "pin_defs.h"
+#include "config_led.h"
 
 /* USB Device descriptor parameter */
 #define VENDOR_ID 0xfeed

keyboards/annepro2/c15/rules.mk

@@ -3,7 +3,9 @@ SRC = \
 	matrix.c \
 	annepro2_ble.c \
 	ap2_led.c \
-	protocol.c
+	protocol.c \
+	rgb_driver.c \
+	config_led.c
 
 # MCU
 MCU = cortex-m0plus
@@ -24,6 +26,7 @@ NKRO_ENABLE = no
 MOUSEKEY_ENABLE = no
 EXTRAKEY_ENABLE = yes
 KEY_LOCK_ENABLE = no
+LAYOUTS = 60_ansi
 
 # Other featues
 BOOTMAGIC_ENABLE = no

keyboards/annepro2/c18/config.h

@@ -18,6 +18,7 @@
 #pragma once
 
 #include "pin_defs.h"
+#include "config_led.h"
 
 /* USB Device descriptor parameter */
 #define VENDOR_ID 0xfeed

keyboards/annepro2/c18/rules.mk

@@ -3,7 +3,9 @@ SRC = \
 	matrix.c \
 	annepro2_ble.c \
 	ap2_led.c \
-	protocol.c
+	protocol.c \
+	rgb_driver.c \
+	config_led.c
 
 # MCU
 MCU = cortex-m0plus
@@ -24,6 +26,7 @@ NKRO_ENABLE = no
 MOUSEKEY_ENABLE = no
 EXTRAKEY_ENABLE = yes
 KEY_LOCK_ENABLE = no
+LAYOUTS = 60_ansi
 
 # Other featues
 BOOTMAGIC_ENABLE = yes

keyboards/annepro2/config_led.c

@@ -0,0 +1,43 @@
+/* Copyright 2022 Jose Pablo Ramirez <jp.ramangulo@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef RGB_MATRIX_ENABLE
+
+#include "rgb_matrix.h"
+#include "config_led.h"
+
+#define NA NO_LED
+
+led_config_t g_led_config = { {
+    { 0,  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, NA },
+    { 41, NA, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, NA },
+    { 53, NA, 54, 55, NA, NA, 56, NA, NA, 57, 58, 59, 60, NA }
+}, {
+    { 0 ,  0 }, { 16,  0 }, { 32,  0 }, { 48,  0 }, { 65,  0 }, { 81,  0 }, { 97 ,  0 }, { 113,  0 }, { 129,  0 }, { 145,  0 }, { 161,  0 }, { 178,  0 }, { 194,  0 }, { 218,  0 },
+    { 4 , 16 }, { 24, 16 }, { 40, 16 }, { 57, 16 }, { 73, 16 }, { 89, 16 }, { 105, 16 }, { 121, 16 }, { 137, 16 }, { 153, 16 }, { 170, 16 }, { 186, 16 }, { 202, 16 }, { 222, 16 },
+    { 6 , 32 }, { 28, 32 }, { 44, 32 }, { 61, 32 }, { 77, 32 }, { 93, 32 }, { 109, 32 }, { 125, 32 }, { 141, 32 }, { 157, 32 }, { 174, 32 }, { 190, 32 }, { 216, 32 },
+    { 10, 48 },             { 36, 48 }, { 52, 48 }, { 69, 48 }, { 85, 48 }, { 101, 48 }, { 117, 48 }, { 133, 48 }, { 149, 48 }, { 165, 48 }, { 182, 48 }, { 212, 48 },
+    { 2 , 64 }, { 22, 64 }, { 42, 64 },                                     { 103, 64 },                           { 163, 64 }, { 184, 64 }, { 204, 64 }, { 224, 64 },
+}, {
+    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,    4,
+    1,    4, 4, 4, 4, 4, 4, 4, 4, 4, 4,    1,
+    1, 1, 1,          4,          1, 1, 1, 1,
+} };
+#endif

keyboards/annepro2/config_led.h

@@ -0,0 +1,72 @@
+/* Copyright 2022 Jose Pablo Ramirez <jp.ramangulo@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#ifdef RGB_MATRIX_ENABLE
+
+#define DRIVER_LED_TOTAL 61
+
+/* Limit animations to 62.5 FPS to avoid tearing. (1/.016 = 62.5 FPS). */
+#define RGB_MATRIX_LED_FLUSH_LIMIT 16
+
+#define RGB_MATRIX_FRAMEBUFFER_EFFECTS
+#define RGB_MATRIX_KEYPRESSES
+#define ENABLE_RGB_MATRIX_ALPHAS_MODS
+#define ENABLE_RGB_MATRIX_GRADIENT_UP_DOWN
+#define ENABLE_RGB_MATRIX_GRADIENT_LEFT_RIGHT
+#define ENABLE_RGB_MATRIX_BREATHING
+#define ENABLE_RGB_MATRIX_BAND_SAT
+#define ENABLE_RGB_MATRIX_BAND_VAL
+#define ENABLE_RGB_MATRIX_BAND_PINWHEEL_SAT
+#define ENABLE_RGB_MATRIX_BAND_PINWHEEL_VAL
+#define ENABLE_RGB_MATRIX_BAND_SPIRAL_SAT
+#define ENABLE_RGB_MATRIX_BAND_SPIRAL_VAL
+#define ENABLE_RGB_MATRIX_CYCLE_ALL
+#define ENABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
+#define ENABLE_RGB_MATRIX_CYCLE_UP_DOWN
+#define ENABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON
+#define ENABLE_RGB_MATRIX_CYCLE_OUT_IN
+#define ENABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL
+#define ENABLE_RGB_MATRIX_CYCLE_PINWHEEL
+#define ENABLE_RGB_MATRIX_CYCLE_SPIRAL
+#define ENABLE_RGB_MATRIX_DUAL_BEACON
+#define ENABLE_RGB_MATRIX_RAINBOW_BEACON
+#define ENABLE_RGB_MATRIX_RAINBOW_PINWHEELS
+#define ENABLE_RGB_MATRIX_RAINDROPS
+#define ENABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS
+#define ENABLE_RGB_MATRIX_HUE_BREATHING
+#define ENABLE_RGB_MATRIX_HUE_PENDULUM
+#define ENABLE_RGB_MATRIX_HUE_WAVE
+#define ENABLE_RGB_MATRIX_PIXEL_FRACTAL
+#define ENABLE_RGB_MATRIX_PIXEL_FLOW
+#define ENABLE_RGB_MATRIX_PIXEL_RAIN
+#define ENABLE_RGB_MATRIX_TYPING_HEATMAP
+#define ENABLE_RGB_MATRIX_DIGITAL_RAIN
+#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE
+#define ENABLE_RGB_MATRIX_SOLID_REACTIVE
+#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE
+#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE
+#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS
+#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS
+#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS
+#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS
+#define ENABLE_RGB_MATRIX_SPLASH
+#define ENABLE_RGB_MATRIX_MULTISPLASH
+#define ENABLE_RGB_MATRIX_SOLID_SPLASH
+#define ENABLE_RGB_MATRIX_SOLID_MULTISPLASH
+
+#endif

keyboards/annepro2/info.json

@@ -3,7 +3,7 @@
     "url": "https://openannepro.github.io/",
     "maintainer": "community",
     "layouts": {
-        "LAYOUT": {
+        "LAYOUT_60_ansi": {
             "layout": [
                 {
                     "label": "~",

keyboards/annepro2/keymaps/default-full-caps/keymap.c

@@ -1,32 +1,31 @@
  /* Copyright 2021 OpenAnnePro community
-  * 
-  * This program is free software: you can redistribute it and/or modify 
-  * it under the terms of the GNU General Public License as published by 
-  * the Free Software Foundation, either version 2 of the License, or 
-  * (at your option) any later version. 
-  * 
-  * This program is distributed in the hope that it will be useful, 
-  * but WITHOUT ANY WARRANTY; without even the implied warranty of 
-  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
-  * GNU General Public License for more details. 
-  * 
-  * You should have received a copy of the GNU General Public License 
-  * along with this program.  If not, see <http://www.gnu.org/licenses/>. 
-  */ 
+  *
+  * This program is free software: you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation, either version 2 of the License, or
+  * (at your option) any later version.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  */
 
 #include QMK_KEYBOARD_H
 
 enum anne_pro_layers {
-    _BASE_LAYER,
-    _FN1_LAYER,
-    _FN2_LAYER,
+    BASE,
+    FN1,
+    FN2,
 };
 
 // clang-format off
-
 // Key symbols are based on QMK. Use them to remap your keyboard
 /*
-* Layer _BASE_LAYER
+* Layer BASE
 * ,-----------------------------------------------------------------------------------------.
 * | esc |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  0  |  -  |  =  |    Bksp   |
 * |-----------------------------------------------------------------------------------------+
@@ -38,7 +37,7 @@ enum anne_pro_layers {
 * |-----------------------------------------------------------------------------------------+
 * | Ctrl  |  L1   |  Alt  |               space             |  Alt  |  FN1  |  FN2  | Ctrl  |
 * \-----------------------------------------------------------------------------------------/
-* Layer TAP in _BASE_LAYER
+* Layer TAP in BASE
 * ,-----------------------------------------------------------------------------------------.
 * |     |     |     |     |     |     |     |     |     |     |     |     |     |           |
 * |-----------------------------------------------------------------------------------------+
@@ -52,15 +51,15 @@ enum anne_pro_layers {
 * \-----------------------------------------------------------------------------------------/
 */
  const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
- [_BASE_LAYER] = LAYOUT( /* Base */
-    KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC,
-    KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS,
-    LT(_FN1_LAYER,KC_CAPS), KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT,
-    KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, RSFT_T(KC_UP),
-    KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, LT(_FN1_LAYER,KC_LEFT), LT(_FN2_LAYER,KC_DOWN), RCTL_T(KC_RGHT)
+ [BASE] = LAYOUT_60_ansi( /* Base */
+    KC_ESC,           KC_1,    KC_2,    KC_3, KC_4, KC_5, KC_6,   KC_7, KC_8, KC_9,    KC_0,             KC_MINS,          KC_EQL,        KC_BSPC,
+    KC_TAB,           KC_Q,    KC_W,    KC_E, KC_R, KC_T, KC_Y,   KC_U, KC_I, KC_O,    KC_P,             KC_LBRC,          KC_RBRC,       KC_BSLS,
+    LT(FN1, KC_CAPS), KC_A,    KC_S,    KC_D, KC_F, KC_G, KC_H,   KC_J, KC_K, KC_L,    KC_SCLN,          KC_QUOT,          KC_ENT,
+    KC_LSFT,                   KC_Z,    KC_X, KC_C, KC_V, KC_B,   KC_N, KC_M, KC_COMM, KC_DOT,           KC_SLSH,          RSFT_T(KC_UP),
+    KC_LCTL,          KC_LGUI, KC_LALT,                   KC_SPC,             KC_RALT, LT(FN1, KC_LEFT), LT(FN2, KC_DOWN), RCTL_T(KC_RGHT)
 ),
   /*
-  * Layer _FN1_LAYER
+  * Layer FN1
   * ,-----------------------------------------------------------------------------------------.
   * |  `  |  F1 |  F2 |  F3 |  F4 |  F5 |  F6 |  F7 |  F8 |  F9 | F10 | F11 | F12 |  DELETE   |
   * |-----------------------------------------------------------------------------------------+
@@ -74,15 +73,15 @@ enum anne_pro_layers {
   * \-----------------------------------------------------------------------------------------/
   *
   */
- [_FN1_LAYER] = LAYOUT( /* Base */
-    KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_DEL,
-    KC_TRNS, KC_TRNS, KC_UP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PSCR, KC_HOME, KC_END, KC_TRNS,
-    KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PGUP, KC_PGDN, KC_TRNS,
-    KC_TRNS, KC_VOLU, KC_VOLD, KC_MUTE, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_INS, KC_DEL, KC_TRNS,
-    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(_FN2_LAYER), KC_TRNS
+ [FN1] = LAYOUT_60_ansi( /* FN1 */
+    KC_GRV,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_DEL,
+    _______, _______, KC_UP,   _______, _______, _______, _______, _______, _______, _______, KC_PSCR, KC_HOME, KC_END,  _______,
+    _______, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______, _______, _______, _______, _______, KC_PGUP, KC_PGDN, _______,
+    _______,          KC_VOLU, KC_VOLD, KC_MUTE, _______, _______, _______, _______, _______, KC_INS,  KC_DEL,  _______,
+    _______, _______, _______,                            _______,                   _______, _______, MO(FN2), _______
 ),
   /*
-  * Layer _FN2_LAYER
+  * Layer FN2
   * ,-----------------------------------------------------------------------------------------.
   * |  ~  | BT1 | BT2 | BT3 | BT4 |  F5 |  F6 |  F7 |LEDOF|LEDON| F10 | F11 | F12 |    Bksp   |
   * |-----------------------------------------------------------------------------------------+
@@ -96,24 +95,23 @@ enum anne_pro_layers {
   * \-----------------------------------------------------------------------------------------/
   *
   */
- [_FN2_LAYER] = LAYOUT( /* Base */
-    KC_TRNS, KC_AP2_BT1, KC_AP2_BT2, KC_AP2_BT3, KC_AP2_BT4, KC_TRNS, KC_TRNS, KC_TRNS, KC_AP_LED_OFF, KC_AP_LED_ON, KC_AP_LED_NEXT_INTENSITY, KC_AP_LED_SPEED, KC_TRNS, KC_TRNS,
-    MO(_FN2_LAYER), KC_TRNS, KC_UP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PSCR, KC_HOME, KC_END, KC_TRNS,
-    KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PGUP, KC_PGDN, KC_TRNS,
-    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_INS, KC_DEL, KC_TRNS,
-    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(_FN1_LAYER), MO(_FN2_LAYER), KC_TRNS
+ [FN2] = LAYOUT_60_ansi( /* FN2 */
+    _______, KC_AP2_BT1, KC_AP2_BT2, KC_AP2_BT3, KC_AP2_BT4, _______, _______, _______, KC_AP_LED_OFF, KC_AP_LED_ON, _______, _______, _______, _______,
+    MO(FN2), _______,    KC_UP,      _______,    _______,    _______, _______, _______, _______,       _______,      KC_PSCR, KC_HOME, KC_END,  _______,
+    _______, KC_LEFT,    KC_DOWN,    KC_RGHT,    _______,    _______, _______, _______, _______,       _______,      KC_PGUP, KC_PGDN, _______,
+    _______,             _______,    _______,    _______,    _______, _______, _______, _______,       _______,      KC_INS,  KC_DEL,  _______,
+    _______, _______,    _______,                                     _______,                         _______,      MO(FN1), MO(FN2), _______
  ),
 };
-
 // clang-format on
 
 // The function to handle the caps lock logic
 bool led_update_user(led_t leds) {
     if (leds.caps_lock) {
         // Set the leds to red
-        annepro2LedSetForegroundColor(0xFF, 0x00, 0x00);
+        ap2_led_set_foreground_color(0xFF, 0x00, 0x00);
     } else {
-        annepro2LedResetForegroundColor();
+        ap2_led_reset_foreground_color();
     }
 
     return true;

keyboards/annepro2/keymaps/default-layer-indicators/keymap.c

@@ -1,32 +1,31 @@
  /* Copyright 2021 OpenAnnePro community
-  * 
-  * This program is free software: you can redistribute it and/or modify 
-  * it under the terms of the GNU General Public License as published by 
-  * the Free Software Foundation, either version 2 of the License, or 
-  * (at your option) any later version. 
-  * 
-  * This program is distributed in the hope that it will be useful, 
-  * but WITHOUT ANY WARRANTY; without even the implied warranty of 
-  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
-  * GNU General Public License for more details. 
-  * 
-  * You should have received a copy of the GNU General Public License 
-  * along with this program.  If not, see <http://www.gnu.org/licenses/>. 
-  */ 
+  *
+  * This program is free software: you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation, either version 2 of the License, or
+  * (at your option) any later version.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  */
 
 #include QMK_KEYBOARD_H
 
 enum anne_pro_layers {
-    _BASE_LAYER,
-    _FN1_LAYER,
-    _FN2_LAYER,
+    BASE,
+    FN1,
+    FN2,
 };
 
 // clang-format off
-
 // Key symbols are based on QMK. Use them to remap your keyboard
 /*
-* Layer _BASE_LAYER
+* Layer BASE
 * ,-----------------------------------------------------------------------------------------.
 * | esc |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  0  |  -  |  =  |    Bksp   |
 * |-----------------------------------------------------------------------------------------+
@@ -38,7 +37,7 @@ enum anne_pro_layers {
 * |-----------------------------------------------------------------------------------------+
 * | Ctrl  |  L1   |  Alt  |               space             |  Alt  |  FN1  |  FN2  | Ctrl  |
 * \-----------------------------------------------------------------------------------------/
-* Layer TAP in _BASE_LAYER
+* Layer TAP in BASE
 * ,-----------------------------------------------------------------------------------------.
 * |     |     |     |     |     |     |     |     |     |     |     |     |     |           |
 * |-----------------------------------------------------------------------------------------+
@@ -52,15 +51,15 @@ enum anne_pro_layers {
 * \-----------------------------------------------------------------------------------------/
 */
  const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
- [_BASE_LAYER] = LAYOUT( /* Base */
-    KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC,
-    KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS,
-    LT(_FN1_LAYER,KC_CAPS), KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT,
-    KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, RSFT_T(KC_UP),
-    KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, LT(_FN1_LAYER,KC_LEFT), LT(_FN2_LAYER,KC_DOWN), RCTL_T(KC_RGHT)
+ [BASE] = LAYOUT_60_ansi( /* Base */
+    KC_ESC,           KC_1,    KC_2,    KC_3, KC_4, KC_5, KC_6,   KC_7, KC_8, KC_9,    KC_0,             KC_MINS,          KC_EQL,        KC_BSPC,
+    KC_TAB,           KC_Q,    KC_W,    KC_E, KC_R, KC_T, KC_Y,   KC_U, KC_I, KC_O,    KC_P,             KC_LBRC,          KC_RBRC,       KC_BSLS,
+    LT(FN1, KC_CAPS), KC_A,    KC_S,    KC_D, KC_F, KC_G, KC_H,   KC_J, KC_K, KC_L,    KC_SCLN,          KC_QUOT,          KC_ENT,
+    KC_LSFT,                   KC_Z,    KC_X, KC_C, KC_V, KC_B,   KC_N, KC_M, KC_COMM, KC_DOT,           KC_SLSH,          RSFT_T(KC_UP),
+    KC_LCTL,          KC_LGUI, KC_LALT,                   KC_SPC,             KC_RALT, LT(FN1, KC_LEFT), LT(FN2, KC_DOWN), RCTL_T(KC_RGHT)
 ),
   /*
-  * Layer _FN1_LAYER
+  * Layer FN1
   * ,-----------------------------------------------------------------------------------------.
   * |  `  |  F1 |  F2 |  F3 |  F4 |  F5 |  F6 |  F7 |  F8 |  F9 | F10 | F11 | F12 |  DELETE   |
   * |-----------------------------------------------------------------------------------------+
@@ -74,15 +73,15 @@ enum anne_pro_layers {
   * \-----------------------------------------------------------------------------------------/
   *
   */
- [_FN1_LAYER] = LAYOUT( /* Base */
-    KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_DEL,
-    KC_TRNS, KC_TRNS, KC_UP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PSCR, KC_HOME, KC_END, KC_TRNS,
-    KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PGUP, KC_PGDN, KC_TRNS,
-    KC_TRNS, KC_VOLU, KC_VOLD, KC_MUTE, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_INS, KC_DEL, KC_TRNS,
-    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(_FN2_LAYER), KC_TRNS
+ [FN1] = LAYOUT_60_ansi( /* FN1 */
+    KC_GRV,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_DEL,
+    _______, _______, KC_UP,   _______, _______, _______, _______, _______, _______, _______, KC_PSCR, KC_HOME, KC_END,  _______,
+    _______, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______, _______, _______, _______, _______, KC_PGUP, KC_PGDN, _______,
+    _______,          KC_VOLU, KC_VOLD, KC_MUTE, _______, _______, _______, _______, _______, KC_INS,  KC_DEL,  _______,
+    _______, _______, _______,                            _______,                   _______, _______, MO(FN2), _______
 ),
   /*
-  * Layer _FN2_LAYER
+  * Layer FN2
   * ,-----------------------------------------------------------------------------------------.
   * |  ~  | BT1 | BT2 | BT3 | BT4 |  F5 |  F6 |  F7 |LEDOF|LEDON| F10 | F11 | F12 |    Bksp   |
   * |-----------------------------------------------------------------------------------------+
@@ -96,30 +95,29 @@ enum anne_pro_layers {
   * \-----------------------------------------------------------------------------------------/
   *
   */
- [_FN2_LAYER] = LAYOUT( /* Base */
-    KC_TRNS, KC_AP2_BT1, KC_AP2_BT2, KC_AP2_BT3, KC_AP2_BT4, KC_TRNS, KC_TRNS, KC_TRNS, KC_AP_LED_OFF, KC_AP_LED_ON, KC_AP_LED_NEXT_INTENSITY, KC_AP_LED_SPEED, KC_TRNS, KC_TRNS,
-    MO(_FN2_LAYER), KC_TRNS, KC_UP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PSCR, KC_HOME, KC_END, KC_TRNS,
-    KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PGUP, KC_PGDN, KC_TRNS,
-    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_INS, KC_DEL, KC_TRNS,
-    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(_FN1_LAYER), MO(_FN2_LAYER), KC_TRNS
+ [FN2] = LAYOUT_60_ansi( /* FN2 */
+    _______, KC_AP2_BT1, KC_AP2_BT2, KC_AP2_BT3, KC_AP2_BT4, _______, _______, _______, KC_AP_LED_OFF, KC_AP_LED_ON, _______, _______, _______, _______,
+    MO(FN2), _______,    KC_UP,      _______,    _______,    _______, _______, _______, _______, _______, KC_PSCR, KC_HOME, KC_END,  _______,
+    _______, KC_LEFT,    KC_DOWN,    KC_RGHT,    _______,    _______, _______, _______, _______, _______, KC_PGUP, KC_PGDN, _______,
+    _______,             _______,    _______,    _______,    _______, _______, _______, _______, _______, KC_INS,  KC_DEL,  _______,
+    _______, _______,    _______,                                     _______,                   _______, MO(FN1), MO(FN2), _______
  ),
 };
-
 // clang-format on
 
 layer_state_t layer_state_set_user(layer_state_t state) {
     switch (get_highest_layer(state)) {
-        case _FN1_LAYER:
+        case FN1:
             // Set the leds to green
-            annepro2LedSetForegroundColor(0x00, 0xFF, 0x00);
+            ap2_led_set_foreground_color(0x00, 0xFF, 0x00);
             break;
-        case _FN2_LAYER:
+        case FN2:
             // Set the leds to blue
-            annepro2LedSetForegroundColor(0x00, 0x00, 0xFF);
+            ap2_led_set_foreground_color(0x00, 0x00, 0xFF);
             break;
         default:
             // Reset back to the current profile
-            annepro2LedResetForegroundColor();
+            ap2_led_reset_foreground_color();
             break;
     }
     return state;
@@ -130,16 +128,16 @@ layer_state_t layer_state_set_user(layer_state_t state) {
 bool led_update_user(led_t leds) {
     if (leds.caps_lock) {
         // Set the caps-lock to red
-        const annepro2Led_t color = {.p.red = 0xff, .p.green = 0x00, .p.blue = 0x00, .p.alpha = 0xff};
+        const ap2_led_t color = {.p.red = 0xff, .p.green = 0x00, .p.blue = 0x00, .p.alpha = 0xff};
 
-        annepro2LedMaskSetKey(2, 0, color);
+        ap2_led_mask_set_key(2, 0, color);
         /* NOTE: Instead of colouring the capslock only, you can change the whole
-           keyboard with annepro2LedSetForegroundColor */
+           keyboard with ap2_led_set_foreground_color */
     } else {
         // Reset the capslock if there is no layer active
-        if (!layer_state_is(_FN1_LAYER) && !layer_state_is(_FN2_LAYER)) {
-            const annepro2Led_t color = {.p.red = 0xff, .p.green = 0x00, .p.blue = 0x00, .p.alpha = 0x00};
-            annepro2LedMaskSetKey(2, 0, color);
+        if (!layer_state_is(FN1) && !layer_state_is(FN2)) {
+            const ap2_led_t color = {.p.red = 0xff, .p.green = 0x00, .p.blue = 0x00, .p.alpha = 0x00};
+            ap2_led_mask_set_key(2, 0, color);
         }
     }
 

keyboards/annepro2/keymaps/default/keymap.c

@@ -1,31 +1,31 @@
  /* Copyright 2021 OpenAnnePro community
-  * 
-  * This program is free software: you can redistribute it and/or modify 
-  * it under the terms of the GNU General Public License as published by 
-  * the Free Software Foundation, either version 2 of the License, or 
-  * (at your option) any later version. 
-  * 
-  * This program is distributed in the hope that it will be useful, 
-  * but WITHOUT ANY WARRANTY; without even the implied warranty of 
-  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
-  * GNU General Public License for more details. 
-  * 
-  * You should have received a copy of the GNU General Public License 
-  * along with this program.  If not, see <http://www.gnu.org/licenses/>. 
-  */ 
+  *
+  * This program is free software: you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation, either version 2 of the License, or
+  * (at your option) any later version.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  */
 
 #include QMK_KEYBOARD_H
 
 enum anne_pro_layers {
-    _BASE_LAYER,
-    _FN1_LAYER,
-    _FN2_LAYER,
+    BASE,
+    FN1,
+    FN2,
 };
 
 // clang-format off
 // Key symbols are based on QMK. Use them to remap your keyboard
 /*
-* Layer _BASE_LAYER
+* Layer BASE
 * ,-----------------------------------------------------------------------------------------.
 * | esc |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  0  |  -  |  =  |    Bksp   |
 * |-----------------------------------------------------------------------------------------+
@@ -37,7 +37,7 @@ enum anne_pro_layers {
 * |-----------------------------------------------------------------------------------------+
 * | Ctrl  |  L1   |  Alt  |               space             |  Alt  |  FN1  |  FN2  | Ctrl  |
 * \-----------------------------------------------------------------------------------------/
-* Layer TAP in _BASE_LAYER
+* Layer TAP in BASE
 * ,-----------------------------------------------------------------------------------------.
 * |     |     |     |     |     |     |     |     |     |     |     |     |     |           |
 * |-----------------------------------------------------------------------------------------+
@@ -51,15 +51,15 @@ enum anne_pro_layers {
 * \-----------------------------------------------------------------------------------------/
 */
  const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
- [_BASE_LAYER] = LAYOUT( /* Base */
-    KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC,
-    KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS,
-    LT(_FN1_LAYER,KC_CAPS), KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT,
-    KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, RSFT_T(KC_UP),
-    KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, LT(_FN1_LAYER,KC_LEFT), LT(_FN2_LAYER,KC_DOWN), RCTL_T(KC_RGHT)
+ [BASE] = LAYOUT_60_ansi( /* Base */
+    KC_ESC,           KC_1,    KC_2,    KC_3, KC_4, KC_5, KC_6,   KC_7, KC_8, KC_9,    KC_0,             KC_MINS,          KC_EQL,        KC_BSPC,
+    KC_TAB,           KC_Q,    KC_W,    KC_E, KC_R, KC_T, KC_Y,   KC_U, KC_I, KC_O,    KC_P,             KC_LBRC,          KC_RBRC,       KC_BSLS,
+    LT(FN1, KC_CAPS), KC_A,    KC_S,    KC_D, KC_F, KC_G, KC_H,   KC_J, KC_K, KC_L,    KC_SCLN,          KC_QUOT,          KC_ENT,
+    KC_LSFT,                   KC_Z,    KC_X, KC_C, KC_V, KC_B,   KC_N, KC_M, KC_COMM, KC_DOT,           KC_SLSH,          RSFT_T(KC_UP),
+    KC_LCTL,          KC_LGUI, KC_LALT,                   KC_SPC,             KC_RALT, LT(FN1, KC_LEFT), LT(FN2, KC_DOWN), RCTL_T(KC_RGHT)
 ),
   /*
-  * Layer _FN1_LAYER
+  * Layer FN1
   * ,-----------------------------------------------------------------------------------------.
   * |  `  |  F1 |  F2 |  F3 |  F4 |  F5 |  F6 |  F7 |  F8 |  F9 | F10 | F11 | F12 |  DELETE   |
   * |-----------------------------------------------------------------------------------------+
@@ -73,17 +73,17 @@ enum anne_pro_layers {
   * \-----------------------------------------------------------------------------------------/
   *
   */
- [_FN1_LAYER] = LAYOUT( /* Base */
-    KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_DEL,
-    KC_TRNS, KC_TRNS, KC_UP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PSCR, KC_HOME, KC_END, KC_TRNS,
-    KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PGUP, KC_PGDN, KC_TRNS,
-    KC_TRNS, KC_VOLU, KC_VOLD, KC_MUTE, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_INS, KC_DEL, KC_TRNS,
-    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(_FN2_LAYER), KC_TRNS
+ [FN1] = LAYOUT_60_ansi( /* FN1 */
+    KC_GRV,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_DEL,
+    _______, _______, KC_UP,   _______, _______, _______, _______, _______, _______, _______, KC_PSCR, KC_HOME, KC_END,  _______,
+    _______, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______, _______, _______, _______, _______, KC_PGUP, KC_PGDN, _______,
+    _______,          KC_VOLU, KC_VOLD, KC_MUTE, _______, _______, _______, _______, _______, KC_INS,  KC_DEL,  _______,
+    _______, _______, _______,                            _______,                   _______, _______, MO(FN2), _______
 ),
   /*
-  * Layer _FN2_LAYER
+  * Layer FN2
   * ,-----------------------------------------------------------------------------------------.
-  * |  ~  | BT1 | BT2 | BT3 | BT4 |  F5 |  F6 |  F7 |LEDOF|LEDON| F10 | F11 | F12 |    Bksp   |
+  * |  ~  | BT1 | BT2 | BT3 | BT4 |  F5 |  F6 | HUE | SAT | BRI | SPD | MOD | TOG |    Bksp   |
   * |-----------------------------------------------------------------------------------------+
   * | Tab    |  q  | UP  |  e  |  r  |  t  |  y  |  u  |  i  |  o  | PS | HOME | END |   \    |
   * |-----------------------------------------------------------------------------------------+
@@ -95,12 +95,12 @@ enum anne_pro_layers {
   * \-----------------------------------------------------------------------------------------/
   *
   */
- [_FN2_LAYER] = LAYOUT( /* Base */
-    KC_TRNS, KC_AP2_BT1, KC_AP2_BT2, KC_AP2_BT3, KC_AP2_BT4, KC_TRNS, KC_TRNS, KC_TRNS, KC_AP_LED_OFF, KC_AP_LED_ON, KC_AP_LED_NEXT_INTENSITY, KC_AP_LED_SPEED, KC_TRNS, KC_TRNS,
-    MO(_FN2_LAYER), KC_TRNS, KC_UP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PSCR, KC_HOME, KC_END, KC_TRNS,
-    KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PGUP, KC_PGDN, KC_TRNS,
-    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_INS, KC_DEL, KC_TRNS,
-    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(_FN1_LAYER), MO(_FN2_LAYER), KC_TRNS
+ [FN2] = LAYOUT_60_ansi( /* FN2 */
+    _______, KC_AP2_BT1, KC_AP2_BT2, KC_AP2_BT3, KC_AP2_BT4, _______, _______, RGB_HUI, RGB_SAI, RGB_VAI, RGB_SPI, RGB_MOD, RGB_TOG, _______,
+    MO(FN2), _______,    KC_UP,      _______,    _______,    _______, _______, _______, _______, _______, KC_PSCR, KC_HOME, KC_END,  _______,
+    _______, KC_LEFT,    KC_DOWN,    KC_RGHT,    _______,    _______, _______, _______, _______, _______, KC_PGUP, KC_PGDN, _______,
+    _______,             _______,    _______,    _______,    _______, _______, _______, _______, _______, KC_INS,  KC_DEL,  _______,
+    _______, _______,    _______,                                     _______,                   _______, MO(FN1), MO(FN2), _______
  ),
 };
 // clang-format on

keyboards/annepro2/keymaps/default/rules.mk

@@ -0,0 +1,3 @@
+# Custom RGB matrix handling
+RGB_MATRIX_ENABLE = yes
+RGB_MATRIX_DRIVER = custom

keyboards/annepro2/protocol.c

@@ -20,38 +20,38 @@
 /* UART communication protocol state */
 protocol_t proto;
 
-void protoInit(protocol_t *proto, void (*callback)(const message_t *)) {
-    proto->previousId = 0;
+void proto_init(protocol_t *proto, void (*callback)(const message_t *)) {
+    proto->previous_id = 0;
     proto->callback   = callback;
     proto->state      = STATE_SYNC_1;
     proto->errors     = 0;
 }
 
-static uint8_t msgId = 0;
-void           protoTx(uint8_t cmd, const unsigned char *buf, int payloadSize, int retries) {
-    chDbgCheck(payloadSize <= MAX_PAYLOAD_SIZE);
+static uint8_t msg_id = 0;
+void           proto_tx(uint8_t cmd, const unsigned char *buf, int payload_size, int retries) {
+    chDbgCheck(payload_size <= MAX_PAYLOAD_SIZE);
 
     const uint8_t header[5] = {
-        0x7A, 0x1D, cmd, ++msgId, payloadSize,
+        0x7A, 0x1D, cmd, ++msg_id, payload_size,
     };
 
     /* We don't implement ACKs, yet some messages should not be lost. */
     for (int i = 0; i < retries; i++) {
         sdWrite(&PROTOCOL_SD, header, sizeof(header));
-        if (payloadSize) sdWrite(&PROTOCOL_SD, buf, payloadSize);
+        if (payload_size) sdWrite(&PROTOCOL_SD, buf, payload_size);
     }
 }
 
 static inline void messageReceived(protocol_t *proto) {
-    if (proto->buffer.msgId != proto->previousId) {
+    if (proto->buffer.msg_id != proto->previous_id) {
         /* It's not a resend / duplicate */
         proto->callback(&proto->buffer);
-        proto->previousId = proto->buffer.msgId;
+        proto->previous_id = proto->buffer.msg_id;
     }
     proto->state = STATE_SYNC_1;
 }
 
-void protoConsume(protocol_t *proto, uint8_t byte) {
+void proto_consume(protocol_t *proto, uint8_t byte) {
     switch (proto->state) {
         case STATE_SYNC_1:
             if (byte == 0x7A) {
@@ -76,18 +76,18 @@ void protoConsume(protocol_t *proto, uint8_t byte) {
             return;
 
         case STATE_ID:
-            proto->buffer.msgId = byte;
+            proto->buffer.msg_id = byte;
             proto->state        = STATE_PAYLOAD_SIZE;
             return;
 
         case STATE_PAYLOAD_SIZE:
-            proto->buffer.payloadSize = byte;
-            if (proto->buffer.payloadSize > MAX_PAYLOAD_SIZE) {
-                proto->buffer.payloadSize = MAX_PAYLOAD_SIZE;
+            proto->buffer.payload_size = byte;
+            if (proto->buffer.payload_size > MAX_PAYLOAD_SIZE) {
+                proto->buffer.payload_size = MAX_PAYLOAD_SIZE;
                 proto->errors++;
             }
-            proto->payloadPosition = 0;
-            if (proto->buffer.payloadSize == 0) {
+            proto->payload_position = 0;
+            if (proto->buffer.payload_size == 0) {
                 /* No payload - whole message received */
                 messageReceived(proto);
             } else {
@@ -98,9 +98,9 @@ void protoConsume(protocol_t *proto, uint8_t byte) {
         case STATE_PAYLOAD:
             /* NOTE: This could be read with sdReadTimeout probably, but that breaks
              * abstraction */
-            proto->buffer.payload[proto->payloadPosition] = byte;
-            proto->payloadPosition++;
-            if (proto->payloadPosition == proto->buffer.payloadSize) {
+            proto->buffer.payload[proto->payload_position] = byte;
+            proto->payload_position++;
+            if (proto->payload_position == proto->buffer.payload_size) {
                 /* Payload read - message received */
                 messageReceived(proto);
             }
@@ -108,7 +108,7 @@ void protoConsume(protocol_t *proto, uint8_t byte) {
     }
 }
 
-void protoSilence(protocol_t *proto) {
+void proto_silence(protocol_t *proto) {
     if (proto->state != STATE_SYNC_1) {
         proto->state = STATE_SYNC_1;
         proto->errors++;

keyboards/annepro2/protocol.h

@@ -55,7 +55,7 @@ enum {
 #define MAX_PAYLOAD_SIZE 64
 
 /** Enum of the states used for the serial protocol finite-state automaton */
-enum protoState {
+enum proto_state {
     /* 2-byte initial start-of-message sync */
     STATE_SYNC_1,
     STATE_SYNC_2,
@@ -65,15 +65,15 @@ enum protoState {
     STATE_ID,
     /* Waiting for payload size */
     STATE_PAYLOAD_SIZE,
-    /* Reading payload until payloadPosition == payloadSize */
+    /* Reading payload until payload_position == payload_size */
     STATE_PAYLOAD,
 };
 
 /* Buffer holding a single message */
 typedef struct {
     uint8_t command;
-    uint8_t msgId;
-    uint8_t payloadSize;
+    uint8_t msg_id;
+    uint8_t payload_size;
     uint8_t payload[MAX_PAYLOAD_SIZE];
 } message_t;
 
@@ -83,12 +83,12 @@ typedef struct {
     void (*callback)(const message_t *);
 
     /* Number of read payload bytes */
-    uint8_t payloadPosition;
+    uint8_t payload_position;
 
     /* Current finite-state-automata state */
-    enum protoState state;
+    enum proto_state state;
 
-    uint8_t previousId;
+    uint8_t previous_id;
     uint8_t errors;
 
     /* Currently received message */
@@ -99,13 +99,13 @@ typedef struct {
 extern protocol_t proto;
 
 /* Init state */
-extern void protoInit(protocol_t *proto, void (*callback)(const message_t *));
+extern void proto_init(protocol_t *proto, void (*callback)(const message_t *));
 
 /* Consume one byte and push state forward - might call the callback */
-extern void protoConsume(protocol_t *proto, uint8_t byte);
+extern void proto_consume(protocol_t *proto, uint8_t byte);
 
 /* Prolonged silence - reset state */
-extern void protoSilence(protocol_t *proto);
+extern void proto_silence(protocol_t *proto);
 
 /* Transmit message */
-extern void protoTx(uint8_t cmd, const unsigned char *buf, int payloadSize, int retries);
+extern void proto_tx(uint8_t cmd, const unsigned char *buf, int payload_size, int retries);

keyboards/annepro2/rgb_driver.c

@@ -0,0 +1,66 @@
+/* Copyright 2022 Jose Pablo Ramirez <jp.ramangulo@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef RGB_MATRIX_ENABLE
+
+#include "rgb_matrix.h"
+#include "ap2_led.h"
+
+uint8_t led_pos[DRIVER_LED_TOTAL];
+
+void init(void) {
+    unsigned int i = 0;
+    for (unsigned int y = 0; y < NUM_ROW; y++) {
+        for (unsigned int x = 0; x < NUM_COLUMN; x++) {
+            if (g_led_config.matrix_co[y][x] != NO_LED) {
+                led_pos[g_led_config.matrix_co[y][x]] = i;
+            }
+            i++;
+        }
+    }
+}
+
+void flush(void) {}
+
+void set_color(int index, uint8_t r, uint8_t g, uint8_t b) {
+    if (r != led_mask[led_pos[index]].p.red   ||
+        g != led_mask[led_pos[index]].p.green ||
+        b != led_mask[led_pos[index]].p.blue)
+        {
+            led_mask[led_pos[index]] = (ap2_led_t){
+                .p.blue  = b,
+                .p.red   = r,
+                .p.green = g,
+                .p.alpha = 0xff,
+            };
+            int row = led_pos[index] / NUM_COLUMN;
+            rgb_row_changed[row] = 1;
+        }
+}
+
+void set_color_all(uint8_t r, uint8_t g, uint8_t b) {
+    for (int i=0; i<DRIVER_LED_TOTAL; i++)
+        set_color(i, r, g, b);
+}
+
+const rgb_matrix_driver_t rgb_matrix_driver = {
+    .init          = init,
+    .flush         = flush,
+    .set_color     = set_color,
+    .set_color_all = set_color_all,
+};
+
+#endif