feat: re-write demo feature to allow for arbitary note trigger

Author: rhargreaves

src/comm/comm_demo.c

@@ -3,55 +3,43 @@
 #include "log.h"
 #include "scheduler.h"
 #include "midi.h"
+#include "ring_buf.h"
 
 #define programChange 0xC0
 #define noteOnStatus 0x90
 #define noteOffStatus 0x80
 #define noteKey 69
 #define noteVelocity 127
 
-#define PROGRAM_INDEX 4
-#define NOTE_KEY_1_INDEX 6
-#define NOTE_ON_END_INDEX 7
-#define NOTE_KEY_2_INDEX 9
-#define NOTE_OFF_END_INDEX 10
-
-#define NOTE_ON_WAIT 50
-#define NOTE_OFF_WAIT 2
-
-static u8 cursor;
-static u16 wait;
 static bool enabled;
 static u8 pitch;
 static u8 program;
+static u16 prev_joy_state;
+static u16 repeat_timer;
+static u16 repeat_button;
 
-u8 track[] = {
-    // CC: show parameters on UI
-    0xB0,
-    CC_SHOW_PARAMETERS_ON_UI,
-    0x7F,
-    // Change program
-    programChange,
-    0,
-    // Note on
-    noteOnStatus,
-    noteKey,
-    noteVelocity,
-    // Note off
-    noteOffStatus,
-    noteKey,
-    noteVelocity,
-};
+#define REPEAT_DELAY 10
+#define INITIAL_DELAY 30
 
 void comm_demo_init(void)
 {
     scheduler_addFrameHandler(comm_demo_vsync);
     JOY_init();
-    cursor = 0;
-    wait = 0;
     enabled = false;
     pitch = noteKey;
     program = 0;
+    prev_joy_state = 0;
+    repeat_timer = 0;
+    repeat_button = 0;
+    ring_buf_init();
+
+    ring_buf_write(0xB0);
+    ring_buf_write(CC_SHOW_PARAMETERS_ON_UI);
+    ring_buf_write(0x7F);
+
+    ring_buf_write(noteOnStatus);
+    ring_buf_write(pitch);
+    ring_buf_write(0x7F);
 }
 
 bool comm_demo_is_present(void)
@@ -64,71 +52,113 @@ u8 comm_demo_read_ready(void)
     if (!enabled) {
         if (JOY_readJoypad(JOY_1) & BUTTON_A) {
             enabled = true;
+        } else {
+            return false;
         }
     }
-    if (!enabled) {
-        return false;
-    }
-    return wait == 0;
+    return ring_buf_can_read();
 }
 
 u8 comm_demo_read(void)
 {
-    if (cursor == 0) {
-        track[PROGRAM_INDEX] = program;
-        track[NOTE_KEY_1_INDEX] = pitch;
-        track[NOTE_KEY_2_INDEX] = pitch;
-        log_info("Demo: Pitch=%d Prg=%d", pitch, program);
-    }
-    u8 data = track[cursor];
-    cursor++;
-    if (cursor == NOTE_ON_END_INDEX + 1) {
-        wait = NOTE_ON_WAIT;
+    u8 data;
+    if (ring_buf_read(&data) == RING_BUF_OK) {
+        return data;
+    } else {
+        return 0;
     }
-    if (cursor == NOTE_OFF_END_INDEX + 1) {
-        wait = NOTE_OFF_WAIT;
-        cursor = 0;
-    }
-    return data;
 }
 
-static void decrement_wait(void)
+static void send_note_off(u8 pitch)
 {
-    if (wait != 0) {
-        wait--;
-    }
+    ring_buf_write(noteOffStatus);
+    ring_buf_write(pitch);
+    ring_buf_write(0);
+}
+
+static void send_note_on(u8 pitch)
+{
+    ring_buf_write(noteOnStatus);
+    ring_buf_write(pitch);
+    ring_buf_write(noteVelocity);
 }
 
-void comm_demo_vsync(u16 wait)
+static void send_program_change(u8 program)
 {
-    decrement_wait();
+    ring_buf_write(programChange);
+    ring_buf_write(program);
+}
 
+static bool should_repeat_button(u16 joy_state, u16 button_mask)
+{
+    if (joy_state & button_mask) {
+        if (repeat_button != button_mask) {
+            repeat_button = button_mask;
+            repeat_timer = 1;
+            return true;
+        } else {
+            repeat_timer++;
+            if (repeat_timer > INITIAL_DELAY
+                && (repeat_timer - INITIAL_DELAY) % REPEAT_DELAY == 0) {
+                return true;
+            }
+        }
+    } else if (repeat_button == button_mask) {
+        repeat_button = 0;
+        repeat_timer = 0;
+    }
+    return false;
+}
+
+void comm_demo_vsync(u16 delta)
+{
     JOY_update();
-    u16 curState = JOY_readJoypad(JOY_1);
-    if (curState & BUTTON_UP) {
+
+    u16 joy_state = JOY_readJoypad(JOY_1);
+
+    if (should_repeat_button(joy_state, BUTTON_UP)) {
+        send_note_off(pitch);
         pitch++;
         if (pitch > MAX_MIDI_PITCH) {
             pitch = MAX_MIDI_PITCH;
         }
+        send_note_on(pitch);
     }
-    if (curState & BUTTON_DOWN) {
+    if (should_repeat_button(joy_state, BUTTON_DOWN)) {
+        send_note_off(pitch);
         pitch--;
         if (pitch < MIN_MIDI_PITCH) {
             pitch = MIN_MIDI_PITCH;
         }
+        send_note_on(pitch);
     }
-    if (curState & BUTTON_RIGHT) {
+    if (should_repeat_button(joy_state, BUTTON_RIGHT)) {
+        send_note_off(pitch);
         program++;
         if (program > 0x7F) {
             program = 0x7F;
         }
+        send_program_change(program);
+        send_note_on(pitch);
     }
-    if (curState & BUTTON_LEFT) {
+    if (should_repeat_button(joy_state, BUTTON_LEFT)) {
+        send_note_off(pitch);
         program--;
         if (program == 0xFF) {
             program = 0;
         }
+        send_program_change(program);
+        send_note_on(pitch);
     }
+    if (should_repeat_button(joy_state, BUTTON_A)) {
+        send_note_off(pitch);
+        send_note_on(pitch);
+    }
+    if (should_repeat_button(joy_state, BUTTON_B)) {
+        send_note_off(pitch);
+    }
+
+    prev_joy_state = joy_state;
 }
 
 u8 comm_demo_write_ready(void)

tests/unit/main.c

@@ -323,6 +323,7 @@ int main(void)
         comm_demo_test(test_comm_demo_decreases_pitch),
         comm_demo_test(test_comm_demo_increases_program),
         comm_demo_test(test_comm_demo_decreases_program),
+        comm_demo_test(test_comm_demo_button_repeat_with_initial_delay),
 
         comm_megawifi_test(test_comm_megawifi_reads_midi_message),
         comm_megawifi_test(test_comm_megawifi_logs_if_buffer_full),

tests/unit/test_comm_demo.c

@@ -44,6 +44,15 @@ static void vsync_call(u16 buttonPressed)
     __real_comm_demo_vsync();
 }
 
+static void vsync_call_multiple(u16 buttonPressed, int times)
+{
+    for (int i = 0; i < times; i++) {
+        expect_function_call(__wrap_JOY_update);
+        will_return(__wrap_JOY_readJoypad, buttonPressed);
+        __real_comm_demo_vsync();
+    }
+}
+
 static void assert_note_played_and_stopped(u8 pitch, u8 program)
 {
     assert_cc(CC_SHOW_PARAMETERS_ON_UI, 0x7F);
@@ -66,52 +75,106 @@ static void assert_note_played_and_stopped(u8 pitch, u8 program)
 void test_comm_demo_plays_note(UNUSED void** state)
 {
     will_return(__wrap_JOY_readJoypad, BUTTON_A);
+    __real_comm_demo_read_ready();
 
-    for (int rep = 0; rep < 10; rep++) {
-        assert_note_played_and_stopped(DEFAULT_PITCH, 0);
+    while (__real_comm_demo_read_ready()) {
+        __real_comm_demo_read();
     }
+
+    vsync_call(BUTTON_A);
+    assert_note_off(DEFAULT_PITCH);
+    assert_note_on(DEFAULT_PITCH, 127);
 }
 
 void test_comm_demo_increases_pitch(UNUSED void** state)
 {
     will_return(__wrap_JOY_readJoypad, BUTTON_A);
-    assert_note_played_and_stopped(DEFAULT_PITCH, 0);
+    __real_comm_demo_read_ready();
+
+    while (__real_comm_demo_read_ready()) {
+        __real_comm_demo_read();
+    }
 
     vsync_call(BUTTON_UP);
-    assert_note_played_and_stopped(DEFAULT_PITCH + 1, 0);
+    assert_note_off(DEFAULT_PITCH);
+    assert_note_on(DEFAULT_PITCH + 1, 127);
 }
 
 void test_comm_demo_decreases_pitch(UNUSED void** state)
 {
     will_return(__wrap_JOY_readJoypad, BUTTON_A);
-    assert_note_played_and_stopped(DEFAULT_PITCH, 0);
+    __real_comm_demo_read_ready();
+
+    while (__real_comm_demo_read_ready()) {
+        __real_comm_demo_read();
+    }
 
     vsync_call(BUTTON_DOWN);
-    assert_note_played_and_stopped(DEFAULT_PITCH - 1, 0);
+    assert_note_off(DEFAULT_PITCH);
+    assert_note_on(DEFAULT_PITCH - 1, 127);
 }
 
 void test_comm_demo_increases_program(UNUSED void** state)
 {
     will_return(__wrap_JOY_readJoypad, BUTTON_A);
-    assert_note_played_and_stopped(DEFAULT_PITCH, 0);
+    __real_comm_demo_read_ready();
+
+    while (__real_comm_demo_read_ready()) {
+        __real_comm_demo_read();
+    }
 
     vsync_call(BUTTON_RIGHT);
-    assert_note_played_and_stopped(DEFAULT_PITCH, 1);
+    assert_note_off(DEFAULT_PITCH);
+    assert_program_change(1);
+    assert_note_on(DEFAULT_PITCH, 127);
 }
 
 void test_comm_demo_decreases_program(UNUSED void** state)
 {
     will_return(__wrap_JOY_readJoypad, BUTTON_A);
-    assert_note_played_and_stopped(DEFAULT_PITCH, 0);
+    __real_comm_demo_read_ready();
 
-    vsync_call(BUTTON_RIGHT);
-    assert_note_played_and_stopped(DEFAULT_PITCH, 1);
+    while (__real_comm_demo_read_ready()) {
+        __real_comm_demo_read();
+    }
 
     vsync_call(BUTTON_RIGHT);
-    assert_note_played_and_stopped(DEFAULT_PITCH, 2);
+    assert_note_off(DEFAULT_PITCH);
+    assert_program_change(1);
+    assert_note_on(DEFAULT_PITCH, 127);
 
     vsync_call(BUTTON_LEFT);
-    assert_note_played_and_stopped(DEFAULT_PITCH, 1);
+    assert_note_off(DEFAULT_PITCH);
+    assert_program_change(0);
+    assert_note_on(DEFAULT_PITCH, 127);
+}
+
+void test_comm_demo_button_repeat_with_initial_delay(UNUSED void** state)
+{
+    will_return(__wrap_JOY_readJoypad, BUTTON_A);
+    __real_comm_demo_read_ready();
+
+    while (__real_comm_demo_read_ready()) {
+        __real_comm_demo_read();
+    }
+
+    vsync_call(BUTTON_UP);
+    assert_note_off(DEFAULT_PITCH);
+    assert_note_on(DEFAULT_PITCH + 1, 127);
+
+    vsync_call_multiple(BUTTON_UP, 38);
+    assert_int_equal(__real_comm_demo_read_ready(), false);
+
+    vsync_call(BUTTON_UP);
+    assert_note_off(DEFAULT_PITCH + 1);
+    assert_note_on(DEFAULT_PITCH + 2, 127);
+
+    vsync_call_multiple(BUTTON_UP, 9);
+    assert_int_equal(__real_comm_demo_read_ready(), false);
+
+    vsync_call(BUTTON_UP);
+    assert_note_off(DEFAULT_PITCH + 2);
+    assert_note_on(DEFAULT_PITCH + 3, 127);
 }
 
 static void assert_read(u8 data)
@@ -131,7 +194,7 @@ static void assert_note_off(u8 pitch)
 {
     assert_read(0x80);
     assert_read(pitch);
-    assert_read(127);
+    assert_read(0);
 }
 
 static void assert_cc(u8 cc, u8 value)

tests/unit/test_comm_demo.h

@@ -8,3 +8,4 @@ void test_comm_demo_increases_pitch(UNUSED void** state);
 void test_comm_demo_decreases_pitch(UNUSED void** state);
 void test_comm_demo_increases_program(UNUSED void** state);
 void test_comm_demo_decreases_program(UNUSED void** state);
+void test_comm_demo_button_repeat_with_initial_delay(UNUSED void** state);