Improve button handling functions

The button handling features are now implemented into three functions:

 * `wait_for_button_timeout` allows the user to answer a yes/no question
   within a defined time.
 * `count_button_presses` allows the user to press the button a certain number
   of times to make a selection.
 * `delay` waits a fixed amount of time, but also reports the number of times
   the button was pressed, allowing the user to interrupt the current
   operation.

The functions also blink the LEDs with controllable on/off times. The delays
or timeouts taken by these functions are now independant from the LEDs times.

The debounce implementation was also greatly improved.

Author: VinDuv

src/lib/user-io.c

@@ -12,6 +12,21 @@
 /* Buzzer (digital pin 2) on port D */
 #define PORTD_BUZZER (1 << 2)
 
+/* Button minimum hold time (ms) -- avoid counting bounces as presses */
+#define BUTTON_HOLD_TIME_MS 20
+
+
+/* Structure to track button presses */
+struct button_info {
+	uint8_t hold_time; /* Time the button was held down */
+	uint8_t count; /* Number of times the button was pressed */
+};
+
+
+/* Static functions */
+static void track_button(struct button_info* info);
+static uint8_t get_tracked_presses(const struct button_info* info);
+
 
 /* Initializes the LED/button interface. */
 void init_led_button(void)
@@ -25,55 +40,104 @@ void init_led_button(void)
 }
 
 
-/* Count the presses on the button during the specified period. */
-uint8_t count_button_presses(uint16_t wait_ms)
+/* Wait the specified amount of time for the button to be pressed. */
+bool wait_for_button_timeout(uint16_t led_on_time_ms, uint16_t led_off_time_ms,
+	uint16_t timeout_ms)
 {
-	uint8_t count = 0;
-	uint8_t press_time = 0;
-
-	while (wait_ms-- > 0) {
-		if (PINB & PORTB_BUTTON) {
-			/* Button not pressed; if it was previously held a sufficient time,
-			   increment the count */
-			if (press_time > 20) {
-				count += 1;
-			}
-			press_time = 0;
-		} else {
-			/* Button pressed; increment the press time */
-			press_time += 1;
+	const uint16_t led_cycle_time_ms = led_on_time_ms + led_off_time_ms;
+	uint16_t led_cycle_pos = 1;
+	struct button_info info = {0, 0};
+
+	while (timeout_ms > 0) {
+		if (led_cycle_pos == 1) {
+			PORTB |= PORTB_LED;
+		} else if (led_cycle_pos == led_on_time_ms) {
+			PORTB &= ~PORTB_LED;
+		} else if (led_cycle_pos == led_cycle_time_ms) {
+			led_cycle_pos = 0;
 		}
 
-		_delay_ms(1);
-	}
+		track_button(&info);
 
-	if (press_time > 20) {
-		count += 1;
+		if (info.count) {
+			break;
+		}
+
+		timeout_ms -= 1;
+		led_cycle_pos += 1;
 	}
 
-	return count;
+	/* Will wait for the button to be released */
+	uint8_t presses = get_tracked_presses(&info);
+	PORTB &= ~PORTB_LED;
+
+	return presses > 0;
 }
 
 
-/* Blink the LED with the specified delays and count. */
-uint8_t blink_led(uint16_t on_time_ms, uint16_t off_time_ms, uint8_t count,
-	bool wait_for_first_press)
+/* Blink the LED and wait for the user to press the button. */
+uint8_t count_button_presses(uint16_t led_on_time_ms,
+	uint16_t led_off_time_ms)
 {
-	uint8_t button_presses = 0;
+	const uint16_t led_cycle_time_ms = led_on_time_ms + led_off_time_ms;
+	uint16_t led_cycle_pos = 1;
+	struct button_info info = {0, 0};
+	uint16_t timeout_ms = 0;
+
+	while ((info.count == 0) || (timeout_ms > 0)) {
+		if (led_cycle_pos == 1) {
+			PORTB |= PORTB_LED;
+		} else if (led_cycle_pos == led_on_time_ms) {
+			PORTB &= ~PORTB_LED;
+		} else if (led_cycle_pos == led_cycle_time_ms) {
+			led_cycle_pos = 0;
+		}
+
+		track_button(&info);
+
+		if (info.hold_time) {
+			timeout_ms = 500;
+		}
+
+		timeout_ms -= 1;
+		led_cycle_pos += 1;
+	}
 
-	while (count > 0) {
-		PORTB |= PORTB_LED;
-		button_presses += count_button_presses(on_time_ms);
+	PORTB &= ~PORTB_LED;
 
-		PORTB &= ~PORTB_LED;
-		button_presses += count_button_presses(off_time_ms);
+	/* Will wait for the button to be released */
+	return get_tracked_presses(&info);
+}
 
-		if (button_presses || !wait_for_first_press) {
-			count -= 1;
+/* Wait a fixed amount of time, blinking the LED */
+uint8_t delay(uint16_t led_on_time_ms, uint16_t led_off_time_ms,
+	uint16_t delay_ms)
+{
+	uint16_t led_cycle_time_ms = led_on_time_ms + led_off_time_ms;
+	uint16_t led_cycle_pos = 1;
+	struct button_info info = {0, 0};
+
+	while (delay_ms > 0) {
+		if (led_on_time_ms != 0) {
+			if (led_cycle_pos == 1) {
+				PORTB |= PORTB_LED;
+			} else if (led_cycle_pos == led_on_time_ms) {
+				PORTB &= ~PORTB_LED;
+			} else if (led_cycle_pos == led_cycle_time_ms) {
+				led_cycle_pos = 0;
+			}
 		}
+
+		track_button(&info);
+
+		delay_ms -= 1;
+		led_cycle_pos += 1;
 	}
 
-	return button_presses;
+	PORTB &= ~PORTB_LED;
+
+	/* Will wait for the button to be released */
+	return get_tracked_presses(&info);
 }
 
 
@@ -84,3 +148,53 @@ void beep(void)
 	_delay_ms(1);
 	PORTD &= ~PORTD_BUZZER;
 }
+
+
+/*
+ * Track the button presses during roughly 1 ms.
+ * The info struct must be initialized to all zeros before calling this
+ * function.
+ */
+void track_button(struct button_info* info)
+{
+	bool button_held = ((PINB & PORTB_BUTTON) == 0);
+
+	if (button_held) {
+		/* The button is held; increment the hold time */
+		info->hold_time += 1;
+
+	} else {
+		/* Check if the button was just released after being held for
+		   a sufficient time */
+		if (info->hold_time > BUTTON_HOLD_TIME_MS) {
+			info->count += 1;
+		}
+
+		info->hold_time = 0;
+	}
+
+	_delay_ms(1);
+}
+
+
+/*
+ * Count the button presses after a tracking operation.
+ */
+uint8_t get_tracked_presses(const struct button_info* info)
+{
+	uint8_t count = info->count;
+
+	/* Wait for the button to be released */
+	while ((PINB & PORTB_BUTTON) == 0) {
+		/* Nothing */
+	}
+
+	/* Count the last button press (if the button was still held the last time
+	   track_button was called */
+	if (info->hold_time > BUTTON_HOLD_TIME_MS) {
+		count += 1;
+	}
+
+	return count;
+}
+

src/lib/user-io.h

@@ -22,20 +22,29 @@
 void init_led_button(void);
 
 /*
- * Count the presses on the button during the specified period.
- * Implements basic debouncing.
+ * Wait the specified amount of time for the button to be pressed. If the
+ * button is not pressed, this function returns false. If the button, is
+ * pressed, this function waits for the button to be released, and returns
+ * true.
  */
-uint8_t count_button_presses(uint16_t wait_ms);
+bool wait_for_button_timeout(uint16_t led_on_time_ms, uint16_t led_off_time_ms,
+	uint16_t timeout_ms);
 
 /*
- * Blink the LED with the specified delays and count. Return the number of
- * times the button was pressed during that time.
+ * Blink the LED and wait for the user to press the button. Return the number
+ * of presses. The user is allowed 500 ms between button presses before this
+ * function returns.
+ */
+uint8_t count_button_presses(uint16_t led_on_time_ms,
+	uint16_t led_off_time_ms);
+
+/*
+ * Wait a fixed amount of time, blinking the LED (unless led_on_time_ms is 0).
  *
- * If wait_for_first_press is true, the count will only start decrementing
- * after the first button press.
+ * Returns the number of times the button was pressed.
  */
-uint8_t blink_led(uint16_t on_time_ms, uint16_t off_time_ms, uint8_t count,
-	bool wait_for_first_press);
+uint8_t delay(uint16_t led_on_time_ms, uint16_t led_off_time_ms,
+	uint16_t delay_ms);
 
 /*
  * Emit a brief beep the buzzer.

src/swsh/swsh.c

@@ -24,15 +24,22 @@ int main(void)
 	/* Initial beep to confirm that the buzzer works */
 	beep();
 
+
 	/* Wait for the user to press the button (should be on the Switch main menu) */
-	blink_led(100, 100, 1, true);
+	count_button_presses(100, 100);
 
 	/* Set the virtual controller as controller 1 */
 	switch_controller(REAL_TO_VIRT, BOTH_LEDS);
 
 	for (;;) {
 		/* Feature selection menu */
-		uint8_t count = blink_led(100, 900, 2, true);
+		uint8_t count = count_button_presses(100, 900);
+
+		for (uint8_t i = 0 ; i < count ; i += 1) {
+			beep();
+			_delay_ms(100);
+		}
+
 
 		switch (count) {
 			case 1:
@@ -49,7 +56,7 @@ int main(void)
 
 			default:
 				/* Wrong selection */
-				blink_led(100, 200, 5, false);
+				delay(100, 200, 1500);
 			break;
 		}
 
@@ -71,7 +78,7 @@ void temporary_control(void)
 	switch_controller(VIRT_TO_REAL, KEEP_LEDS);
 
 	/* Wait for the user to press the button (should be on the Switch main menu) */
-	blink_led(100, 100, 1, true);
+	count_button_presses(100, 100);
 
 	/* Set the virtual controller as controller 1 */
 	switch_controller(REAL_TO_VIRT, BOTH_LEDS);
@@ -84,7 +91,7 @@ void temporary_control(void)
 static void repeat_press_a(void)
 {
 	uint8_t count = 0;
-	while (count_button_presses(50) == 0) {
+	while (delay(0, 0, 50) == 0) {
 		switch (count % 4) {
 			case 0:
 				set_leds(NO_LEDS);
@@ -132,7 +139,7 @@ void max_raid(void)
 		use_wishing_piece_and_pause();
 
 		/* Let the user choose what to do */
-		if (blink_led(250, 250, 10, false)) {
+		if (wait_for_button_timeout(250, 250, 5000)) {
 			/* User confirmed, continue */
 			break;
 		}
@@ -165,7 +172,7 @@ void max_raid(void)
 		beep();
 
 		/* Do the user wants to do this Raid? */
-		if (blink_led(250, 250, 10, false)) {
+		if (wait_for_button_timeout(250, 250, 5000)) {
 			/* Restore the clock */
 			set_leds(NO_LEDS);
 			set_clock_to_auto_from_manual(/* in_game */ true, KEEP_LEDS);
@@ -174,7 +181,7 @@ void max_raid(void)
 			switch_controller(VIRT_TO_REAL, KEEP_LEDS);
 
 			/* Wait for the user to press the button */
-			uint8_t result = blink_led(100, 100, 1, true);
+			uint8_t result = count_button_presses(100, 100);
 
 			/* Get back control */
 			switch_controller(REAL_TO_VIRT, KEEP_LEDS);