3 files changed, 38 insertions(+), 16 deletions(-)

M quantum/action.c
M quantum/send_string/send_string.c
M quantum/send_string/send_string.h

@@ 1011,9 1011,7 @@ __attribute__((weak)) void unregister_code(uint8_t code) {
  */
 __attribute__((weak)) void tap_code_delay(uint8_t code, uint16_t delay) {
     register_code(code);
-    for (uint16_t i = delay; i > 0; i--) {
-        wait_ms(1);
-    }
+    wait_ms(delay);
     unregister_code(code);
 }
 

@@ 147,7 147,7 @@ __attribute__((weak)) const uint8_t ascii_to_keycode_lut[128] PROGMEM = {
 #define PGM_LOADBIT(mem, pos) ((pgm_read_byte(&((mem)[(pos) / 8])) >> ((pos) % 8)) & 0x01)
 
 void send_string(const char *string) {
-    send_string_with_delay(string, 0);
+    send_string_with_delay(string, TAP_CODE_DELAY);
 }
 
 void send_string_with_delay(const char *string, uint8_t interval) {


@@ 156,6 156,7 @@ void send_string_with_delay(const char *string, uint8_t interval) {
         if (!ascii_code) break;
         if (ascii_code == SS_QMK_PREFIX) {
             ascii_code = *(++string);
+
             if (ascii_code == SS_TAP_CODE) {
                 // tap
                 uint8_t keycode = *(++string);


@@ 172,28 173,30 @@ void send_string_with_delay(const char *string, uint8_t interval) {
                 // delay
                 int     ms      = 0;
                 uint8_t keycode = *(++string);
+
                 while (isdigit(keycode)) {
                     ms *= 10;
                     ms += keycode - '0';
                     keycode = *(++string);
                 }
-                while (ms--)
-                    wait_ms(1);
+
+                wait_ms(ms);
             }
+
+            wait_ms(interval);
         } else {
-            send_char(ascii_code);
+            send_char_with_delay(ascii_code, interval);
         }
+
         ++string;
-        // interval
-        {
-            uint8_t ms = interval;
-            while (ms--)
-                wait_ms(1);
-        }
     }
 }
 
 void send_char(char ascii_code) {
+    send_char_with_delay(ascii_code, TAP_CODE_DELAY);
+}
+
+void send_char_with_delay(char ascii_code, uint8_t interval) {
 #if defined(AUDIO_ENABLE) && defined(SENDSTRING_BELL)
     if (ascii_code == '\a') { // BEL
         PLAY_SONG(bell_song);


@@ 208,19 211,30 @@ void send_char(char ascii_code) {
 
     if (is_shifted) {
         register_code(KC_LEFT_SHIFT);
+        wait_ms(interval);
     }
+
     if (is_altgred) {
         register_code(KC_RIGHT_ALT);
+        wait_ms(interval);
     }
-    tap_code(keycode);
+
+    tap_code_delay(keycode, interval);
+    wait_ms(interval);
+
     if (is_altgred) {
         unregister_code(KC_RIGHT_ALT);
+        wait_ms(interval);
     }
+
     if (is_shifted) {
         unregister_code(KC_LEFT_SHIFT);
+        wait_ms(interval);
     }
+
     if (is_dead) {
         tap_code(KC_SPACE);
+        wait_ms(interval);
     }
 }
 

@@ 49,7 49,7 @@ extern const uint8_t ascii_to_keycode_lut[128];
 /**
  * \brief Type out a string of ASCII characters.
  *
- * This function simply calls `send_string_with_delay(string, 0)`.
+ * This function simply calls `send_string_with_delay(string, TAP_CODE_DELAY)`.
  *
  * Most keycodes from the basic keycode range are also supported by way of a special sequence - see `send_string_keycodes.h`.
  *


@@ 61,18 61,28 @@ void send_string(const char *string);
  * \brief Type out a string of ASCII characters, with a delay between each character.
  *
  * \param string The string to type out.
- * \param interval The amount of time, in milliseconds, to wait before typing the next character.
+ * \param interval The amount of time, in milliseconds, to wait before typing the next character. Note this can be set to 0 to ensure no delay, regardless of what TAP_CODE_DELAY is set to.
  */
 void send_string_with_delay(const char *string, uint8_t interval);
 
 /**
  * \brief Type out an ASCII character.
  *
+ * This function simply calls `send_char_with_delay(string, TAP_CODE_DELAY)`.
+ *
  * \param ascii_code The character to type.
  */
 void send_char(char ascii_code);
 
 /**
+ * \brief Type out an ASCII character, with a delay between any modifiers.
+ *
+ * \param ascii_code The character to type.
+ * \param interval The amount of time, in milliseconds, to wait in between key presses. Note this can be set to 0 to ensure no delay, regardless of what TAP_CODE_DELAY is set to.
+ */
+void send_char_with_delay(char ascii_code, uint8_t interval);
+
+/**
  * \brief Type out an eight digit (unsigned 32-bit) hexadecimal value.
  *
  * The format is `[0-9a-f]{8}`, eg. `00000000` through `ffffffff`.