codal_port: Support selecting pin/speaker in audio/music/speech modules.

The default selection for sound output is (pin0, pin_speaker) but this can
be changed by specifying the "pin" keyword-argument to the relevant sound
functions/methods.

Author: dpgeorge

src/codal_port/Makefile

@@ -66,6 +66,7 @@ SRC_C += \
 	microbit_constimage.c \
 	microbit_microphone.c \
 	microbit_pin.c \
+	microbit_pinaudio.c \
 	microbit_pinmode.c \
 	microbit_soundevent.c \
 	microbit_spi.c \

src/codal_port/microbit_pin.c

@@ -50,7 +50,6 @@ const microbit_pin_obj_t microbit_p20_obj = {{&microbit_dig_pin_type},  20, MICR
 
 const microbit_pin_obj_t microbit_pin_logo_obj = {{&microbit_touch_only_pin_type}, 30, MICROBIT_HAL_PIN_FACE, MODE_UNUSED};
 const microbit_pin_obj_t microbit_pin_speaker_obj = {{&microbit_dig_pin_type}, 31, MICROBIT_HAL_PIN_SPEAKER, MODE_UNUSED};
-const microbit_pin_obj_t microbit_pin_audio_obj = {{&microbit_dig_pin_type}, 33, MICROBIT_HAL_PIN_AUDIO, MODE_UNUSED};
 
 static mp_obj_t microbit_pin_get_mode_func(mp_obj_t self_in) {
     microbit_pin_obj_t *self = (microbit_pin_obj_t*)self_in;

src/codal_port/microbit_pinaudio.c

@@ -0,0 +1,121 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "microbithal.h"
+#include "modmicrobit.h"
+
+const mp_obj_tuple_t microbit_pin_default_audio_obj = {
+    { &mp_type_tuple },
+    2,
+    {
+        (mp_obj_t)MP_ROM_PTR(&microbit_p0_obj),
+        (mp_obj_t)MP_ROM_PTR(&microbit_pin_speaker_obj),
+    }
+};
+
+// Whether the speaker is enabled or not.  If true, this overrides any selection
+// of the speaker to act as though it was not selected.
+STATIC bool audio_speaker_enabled = true;
+
+// The currently selected pin and/or speaker output for the audio.
+STATIC const microbit_pin_obj_t *audio_routed_pin = NULL;
+STATIC bool audio_routed_speaker = false;
+
+STATIC void microbit_pin_audio_get_pins(mp_const_obj_t select, const microbit_pin_obj_t **pin_selected, bool *speaker_selected) {
+    // Convert the "select" object into an array of items (which should be pins).
+    size_t len;
+    mp_obj_t *items;
+    if (mp_obj_is_type(select, &mp_type_tuple)) {
+        mp_obj_get_array((mp_obj_t)select, &len, &items);
+        if (len > 2) {
+            mp_raise_ValueError(MP_ERROR_TEXT("maximum of 2 pins allowed"));
+        }
+    } else {
+        len = 1;
+        items = (mp_obj_t *)&select;
+    }
+
+    // Work out which pins are selected for the audio output.
+    *pin_selected = NULL;
+    *speaker_selected = false;
+    if (len == 1 || len == 2) {
+        if (items[0] == &microbit_pin_speaker_obj) {
+            *speaker_selected = true;
+        } else {
+            *pin_selected = microbit_obj_get_pin(items[0]);
+        }
+        if (len == 2) {
+            if (items[1] == &microbit_pin_speaker_obj) {
+                if (*speaker_selected) {
+                    mp_raise_ValueError(MP_ERROR_TEXT("speaker selected twice"));
+                }
+                *speaker_selected = true;
+            } else {
+                if (*pin_selected != NULL) {
+                    mp_raise_ValueError(MP_ERROR_TEXT("can only select one non-speaker pin"));
+                }
+                *pin_selected = microbit_obj_get_pin(items[1]);
+            }
+        }
+    }
+
+    // Apply global override to enable/disable speaker.
+    *speaker_selected = *speaker_selected && audio_speaker_enabled;
+}
+
+void microbit_pin_audio_select(mp_const_obj_t select) {
+    // Work out which pins are selected.
+    const microbit_pin_obj_t *pin_selected;
+    bool speaker_selected;
+    microbit_pin_audio_get_pins(select, &pin_selected, &speaker_selected);
+
+    // Change the pin if needed.
+    if (pin_selected != audio_routed_pin) {
+        if (audio_routed_pin != NULL) {
+            microbit_obj_pin_free(audio_routed_pin);
+        }
+        audio_routed_pin = pin_selected;
+        if (audio_routed_pin == NULL) {
+            microbit_hal_audio_select_pin(-1);
+        } else {
+            microbit_obj_pin_acquire(audio_routed_pin, microbit_pin_mode_music);
+            microbit_hal_audio_select_pin(audio_routed_pin->name);
+        }
+    }
+
+    // Change the speaker mode if needed.
+    if (speaker_selected != audio_routed_speaker) {
+        audio_routed_speaker = speaker_selected;
+        microbit_hal_audio_select_speaker(audio_routed_speaker);
+    }
+}
+
+void microbit_pin_audio_free(void) {
+    if (audio_routed_pin != NULL) {
+        microbit_obj_pin_free(audio_routed_pin);
+        audio_routed_pin = NULL;
+    }
+}

src/codal_port/modaudio.c

@@ -41,34 +41,13 @@
 #define BUFFER_EXPANSION (16)
 
 static volatile bool running = false;
-static bool double_pin = true;
-static const microbit_pin_obj_t *pin0 = NULL;
-static const microbit_pin_obj_t *pin1 = NULL;
-static const microbit_pin_obj_t *big_pins[3] = { &microbit_p0_obj, &microbit_p1_obj, &microbit_p2_obj };
 
 microbit_audio_frame_obj_t *microbit_audio_frame_make_new(void);
 
 void microbit_audio_stop(void) {
     audio_source_iter = NULL;
     running = false;
-    microbit_obj_pin_free(pin0);
-    if (double_pin) {
-        microbit_obj_pin_free(pin1);
-    }
-}
-
-static void init_pin(const microbit_pin_obj_t *p0) {
-    microbit_obj_pin_acquire(p0, microbit_pin_mode_audio_play);
-    pin0 = p0;
-    double_pin = false;
-}
-
-static void init_pins(const microbit_pin_obj_t *p0, const microbit_pin_obj_t *p1) {
-    microbit_obj_pin_acquire(p1, microbit_pin_mode_audio_play);
-    microbit_obj_pin_acquire(p0, microbit_pin_mode_audio_play);
-    pin0 = p0;
-    pin1 = p1;
-    double_pin = true;
+    microbit_pin_audio_free();
 }
 
 STATIC void audio_data_fetcher(void) {
@@ -131,68 +110,6 @@ void microbit_hal_audio_ready_callback(void) {
     mp_sched_schedule(MP_OBJ_FROM_PTR(&audio_data_fetcher_wrapper_obj), mp_const_none);
 }
 
-static void audio_set_pins(mp_obj_t pin0_obj, mp_obj_t pin1_obj) {
-    const microbit_pin_obj_t *p0 = microbit_obj_get_pin(pin0_obj);
-    if (pin1_obj == mp_const_none) {
-        init_pin(p0);
-    } else {
-        const microbit_pin_obj_t *p1 = microbit_obj_get_pin(pin1_obj);
-        init_pins(p0, p1);
-    }
-}
-
-static int32_t pin_read_digital(const microbit_pin_obj_t *pin) {
-    nrf_gpio_cfg_input(pin->name, NRF_GPIO_PIN_NOPULL);
-    // Allow 1us to settle.
-    mp_hal_delay_us(1);
-    return nrf_gpio_pin_read(pin->name);
-}
-
-static void audio_auto_set_pins(void) {
-    audio_set_pins((mp_obj_t)&microbit_pin_speaker_obj, mp_const_none);
-    return;
-    // Test to see if two of the "big" pins are connected by some sort of resistor.
-    uint32_t i, j, count;
-    bool usable[3];
-    if (microbit_obj_pin_can_be_acquired(&microbit_p0_obj)) {
-        usable[0] = true;
-        microbit_obj_pin_acquire(&microbit_p0_obj, microbit_pin_mode_unused);
-    }
-    if (microbit_obj_pin_can_be_acquired(&microbit_p1_obj)) {
-        usable[1] = true;
-        microbit_obj_pin_acquire(&microbit_p1_obj, microbit_pin_mode_unused);
-    }
-    if (microbit_obj_pin_can_be_acquired(&microbit_p2_obj)) {
-        usable[2] = true;
-        microbit_obj_pin_acquire(&microbit_p2_obj, microbit_pin_mode_unused);
-    }
-    for (i = 0; i < 2; i++) {
-        if (!usable[i])
-            continue;
-        const microbit_pin_obj_t *pin1 = big_pins[i];
-        nrf_gpio_cfg_output(pin1->name);
-        for (j = i+1; j < 3; j++) {
-            if (!usable[j])
-                continue;
-            const microbit_pin_obj_t *pin2 = big_pins[j];
-            for (count = 0; count < 4; count++) {
-                nrf_gpio_pin_set(pin1->name);
-                if (pin_read_digital(pin2) != 1)
-                    break;
-                nrf_gpio_pin_clear(pin1->name);
-                if (pin_read_digital(pin2) != 0)
-                    break;
-            }
-            if (count == 4) {
-                init_pins(pin1, pin2);
-                return;
-            }
-        }
-    }
-    /* Set to default: single pin0 */
-    audio_set_pins((mp_obj_t)&microbit_p0_obj, mp_const_none);
-}
-
 static void audio_init(uint32_t sample_rate) {
     if (audio_buffer_ptr == NULL) {
         audio_source_iter = NULL;
@@ -201,22 +118,12 @@ static void audio_init(uint32_t sample_rate) {
     microbit_hal_audio_init(BUFFER_EXPANSION / 4 * sample_rate);
 }
 
-void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin1, mp_obj_t pin2, bool wait, uint32_t sample_rate) {
+void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, uint32_t sample_rate) {
     if (running) {
         microbit_audio_stop();
     }
     audio_init(sample_rate);
-    if (0) {
-    if (pin1 == mp_const_none) {
-        if (pin2 == mp_const_none) {
-            audio_auto_set_pins();
-        } else {
-            mp_raise_TypeError("cannot set return_pin without pin");
-        }
-    } else {
-        audio_set_pins(pin1, pin2);
-    }
-    }
+    microbit_pin_audio_select(pin_select);
 
     audio_source_iter = NULL;
 
@@ -254,10 +161,14 @@ STATIC mp_obj_t play(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_ar
     // parse args
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // The return_pin argument from micro:bit v1 is no longer supported.
+    if (args[3].u_obj != mp_const_none) {
+        mp_raise_ValueError("return_pin not supported");
+    }
+
     mp_obj_t src = args[0].u_obj;
-    mp_obj_t pin1 = args[2].u_obj;
-    mp_obj_t pin2 = args[3].u_obj;
-    microbit_audio_play_source(src, pin1, pin2, args[1].u_bool, DEFAULT_SAMPLE_RATE);
+    microbit_audio_play_source(src, args[2].u_obj, args[1].u_bool, DEFAULT_SAMPLE_RATE);
     return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(microbit_audio_play_obj, 0, play);

src/codal_port/modaudio.h

@@ -39,7 +39,7 @@ typedef struct _microbit_audio_frame_obj_t {
 
 extern const mp_obj_type_t microbit_audio_frame_type;
 
-void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin1, mp_obj_t pin2, bool wait, uint32_t sample_rate);
+void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, uint32_t sample_rate);
 void microbit_audio_stop(void);
 bool microbit_audio_is_playing(void);
 microbit_audio_frame_obj_t *microbit_audio_frame_make_new(void);

src/codal_port/modmicrobit.c

@@ -136,7 +136,6 @@ STATIC const mp_rom_map_elem_t microbit_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_pin20), MP_ROM_PTR(&microbit_p20_obj) },
     { MP_ROM_QSTR(MP_QSTR_pin_logo), MP_ROM_PTR(&microbit_pin_logo_obj) },
     { MP_ROM_QSTR(MP_QSTR_pin_speaker), MP_ROM_PTR(&microbit_pin_speaker_obj) },
-    { MP_ROM_QSTR(MP_QSTR_pin_audio), MP_ROM_PTR(&microbit_pin_audio_obj) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(microbit_module_globals, microbit_module_globals_table);

src/codal_port/modmicrobit.h

@@ -100,7 +100,6 @@ extern const struct _microbit_pin_obj_t microbit_p19_obj;
 extern const struct _microbit_pin_obj_t microbit_p20_obj;
 extern const struct _microbit_pin_obj_t microbit_pin_logo_obj;
 extern const struct _microbit_pin_obj_t microbit_pin_speaker_obj;
-extern const struct _microbit_pin_obj_t microbit_pin_audio_obj;
 
 extern const struct _microbit_i2c_obj_t microbit_i2c_obj;
 extern const struct _microbit_uart_obj_t microbit_uart_obj;
@@ -182,7 +181,8 @@ extern const struct _microbit_microphone_obj_t microbit_microphone_obj;
 extern const struct _microbit_button_obj_t microbit_button_a_obj;
 extern const struct _microbit_button_obj_t microbit_button_b_obj;
 
-extern uint16_t microbit_volume_global;
+//extern uint16_t microbit_volume_global;
+extern const mp_obj_tuple_t microbit_pin_default_audio_obj;
 
 const microbit_pin_obj_t *microbit_obj_get_pin(mp_obj_t o);
 
@@ -202,6 +202,9 @@ bool microbit_obj_pin_acquire(const microbit_pin_obj_t *pin, const microbit_pinm
 const microbit_pinmode_t *microbit_pin_get_mode(const microbit_pin_obj_t *pin);
 void pinmode_error(const microbit_pin_obj_t *pin);
 
+void microbit_pin_audio_select(mp_const_obj_t select);
+void microbit_pin_audio_free(void);
+
 MP_DECLARE_CONST_FUN_OBJ_0(microbit_reset_obj);
 
 #endif // MICROPY_INCLUDED_MICROBIT_MODMICROBIT_H