pxt-microbit 4.1.18 → 4.1.21

package/built/sim.js

@@ -2361,699 +2361,62 @@ var pxsim;
         serial.setBaudRate = setBaudRate;
     })(serial = pxsim.serial || (pxsim.serial = {}));
 })(pxsim || (pxsim = {}));
-/**
- * Adapted from lancaster-university/codal-microbit-v2
- * https://github.com/lancaster-university/codal-microbit-v2/blob/master/source/SoundEmojiSynthesizer.cpp
- */
 var pxsim;
 (function (pxsim) {
     var music;
     (function (music) {
-        // https://github.com/lancaster-university/codal-microbit-v2/blob/master/inc/SoundEmojiSynthesizer.h#L30
-        music.EMOJI_SYNTHESIZER_SAMPLE_RATE = 44100;
-        music.EMOJI_SYNTHESIZER_TONE_WIDTH_F = 1024;
-        music.EMOJI_SYNTHESIZER_TONE_WIDTH = 1024;
-        music.EMOJI_SYNTHESIZER_BUFFER_SIZE = 512;
-        music.EMOJI_SYNTHESIZER_TONE_EFFECT_PARAMETERS = 2;
-        music.EMOJI_SYNTHESIZER_TONE_EFFECTS = 3;
-        music.EMOJI_SYNTHESIZER_STATUS_ACTIVE = 0x1;
-        music.EMOJI_SYNTHESIZER_STATUS_OUTPUT_SILENCE_AS_EMPTY = 0x2;
-        music.EMOJI_SYNTHESIZER_STATUS_STOPPING = 0x4;
-        class SoundEmojiSynthesizer {
-            constructor(id, sampleRate = music.EMOJI_SYNTHESIZER_SAMPLE_RATE) {
-                this.samplesPerStep = [];
-                this.status = 0;
-                this.effectPointer = 0;
-                this.position = 0;
-                this.bufferSize = music.EMOJI_SYNTHESIZER_BUFFER_SIZE;
-                this.sampleRate = sampleRate;
-                this.samplesToWrite = 0;
-                this.samplesWritten = 0;
-                this.sampleRange = 1023;
-                this.orMask = 0;
-                this.effectPointer = -1;
-                this.volume = 1;
-            }
-            get effect() {
-                return this.effectBuffer[this.effectPointer];
-            }
-            play(sound) {
-                this.effectBuffer = sound;
-                this.effectPointer = -1;
-                this.nextSoundEffect();
-            }
-            nextSoundEffect() {
-                const hadEffect = this.effect != null;
-                if (this.status & music.EMOJI_SYNTHESIZER_STATUS_STOPPING) {
-                    this.effectPointer = null;
-                    this.effectBuffer = [];
-                }
-                // If a sequence of SoundEffects are being played, attempt to move on to the next.
-                // If not, select the first in the buffer.
-                if (this.effect)
-                    this.effectPointer++;
-                else
-                    this.effectPointer = 0;
-                // Validate that we have a valid sound effect. If not, record that we have nothing to play.
-                if (this.effectPointer >= this.effectBuffer.length) {
-                    // if we have an effect with a negative duration, reset the buffer (unless there is an update pending)
-                    this.effectPointer = 0;
-                    if (this.effect.duration >= 0) {
-                        this.effectPointer = -1;
-                        this.effectBuffer = [];
-                        this.samplesWritten = 0;
-                        this.samplesToWrite = 0;
-                        this.position = 0;
-                        return hadEffect;
-                    }
-                }
-                // We have a valid buffer. Set up our synthesizer to the requested parameters.
-                this.samplesToWrite = this.determineSampleCount(this.effect.duration);
-                this.frequency = this.effect.frequency;
-                this.volume = this.effect.volume;
-                this.samplesWritten = 0;
-                // validate and initialise per effect rendering state.
-                for (let i = 0; i < music.EMOJI_SYNTHESIZER_TONE_EFFECTS; i++) {
-                    this.effect.effects[i].step = 0;
-                    this.effect.effects[i].steps = Math.max(this.effect.effects[i].steps, 1);
-                    this.samplesPerStep[i] = Math.floor(this.samplesToWrite / this.effect.effects[i].steps);
-                }
-                return false;
-            }
-            pull() {
-                let done = false;
-                let sample;
-                let bufferEnd;
-                while (!done) {
-                    if (this.samplesWritten == this.samplesToWrite || this.status & music.EMOJI_SYNTHESIZER_STATUS_STOPPING) {
-                        let renderComplete = this.nextSoundEffect();
-                        // If we have just completed active playout of an effect, and there are no more effects scheduled,
-                        // unblock any fibers that may be waiting to play a sound effect.
-                        if (this.samplesToWrite == 0 || this.status & music.EMOJI_SYNTHESIZER_STATUS_STOPPING) {
-                            done = true;
-                            if (renderComplete || this.status & music.EMOJI_SYNTHESIZER_STATUS_STOPPING) {
-                                this.status &= ~music.EMOJI_SYNTHESIZER_STATUS_STOPPING;
-                                // Event(id, DEVICE_SOUND_EMOJI_SYNTHESIZER_EVT_DONE);
-                                // lock.notify();
-                            }
-                        }
-                    }
-                    // If we have something to do, ensure our buffers are created.
-                    // We defer creation to avoid unnecessary heap allocation when generating silence.
-                    if (((this.samplesWritten < this.samplesToWrite) || !(this.status & music.EMOJI_SYNTHESIZER_STATUS_OUTPUT_SILENCE_AS_EMPTY)) && sample == null) {
-                        this.buffer = new Array(this.bufferSize);
-                        sample = 0;
-                        bufferEnd = this.buffer.length;
-                    }
-                    // Generate some samples with the current this.effect parameters.
-                    while (this.samplesWritten < this.samplesToWrite) {
-                        let skip = ((music.EMOJI_SYNTHESIZER_TONE_WIDTH_F * this.frequency) / this.sampleRate);
-                        let gain = (this.sampleRange * this.volume) / 1024;
-                        let offset = 512 - (512 * gain);
-                        let effectStepEnd = [];
-                        for (let i = 0; i < music.EMOJI_SYNTHESIZER_TONE_EFFECTS; i++) {
-                            effectStepEnd[i] = (this.samplesPerStep[i] * (this.effect.effects[i].step));
-                            if (this.effect.effects[i].step == this.effect.effects[i].steps - 1)
-                                effectStepEnd[i] = this.samplesToWrite;
-                        }
-                        let stepEndPosition = effectStepEnd[0];
-                        for (let i = 1; i < music.EMOJI_SYNTHESIZER_TONE_EFFECTS; i++)
-                            stepEndPosition = Math.min(stepEndPosition, effectStepEnd[i]);
-                        // Write samples until the end of the next this.effect-step
-                        while (this.samplesWritten < stepEndPosition) {
-                            // Stop processing when we've filled the requested this.buffer
-                            if (sample == bufferEnd) {
-                                // downStream.pullRequest();
-                                return this.buffer;
-                            }
-                            // Synthesize a sample
-                            let s = this.effect.tone.tonePrint(this.effect.tone.parameter, this.position);
-                            // Apply volume scaling and OR mask (if specified).
-                            this.buffer[sample] = (((s * gain) + offset)); // | this.orMask;
-                            // Move on our pointers.
-                            sample++;
-                            this.samplesWritten++;
-                            this.position += skip;
-                            // Keep our toneprint pointer in range
-                            while (this.position > music.EMOJI_SYNTHESIZER_TONE_WIDTH_F)
-                                this.position -= music.EMOJI_SYNTHESIZER_TONE_WIDTH_F;
-                        }
-                        // Invoke the this.effect function for any effects that are due.
-                        for (let i = 0; i < music.EMOJI_SYNTHESIZER_TONE_EFFECTS; i++) {
-                            if (this.samplesWritten == effectStepEnd[i]) {
-                                if (this.effect.effects[i].step < this.effect.effects[i].steps) {
-                                    if (this.effect.effects[i].effect)
-                                        this.effect.effects[i].effect(this, this.effect.effects[i]);
-                                    this.effect.effects[i].step++;
-                                }
-                            }
-                        }
-                    }
-                }
-                // if we have no data to send, return an empty this.buffer (if requested)
-                if (sample == null) {
-                    this.buffer = [];
-                }
-                else {
-                    // Pad the output this.buffer with silence if necessary.
-                    const silence = (this.sampleRange * 0.5); // | this.orMask;
-                    while (sample < bufferEnd) {
-                        this.buffer[sample] = silence;
-                        sample++;
-                    }
-                }
-                // Issue a Pull Request so that we are always receiver driven, and we're done.
-                // downStream.pullRequest();
-                return this.buffer;
-            }
-            determineSampleCount(playoutTime) {
-                if (playoutTime < 0)
-                    playoutTime = -playoutTime;
-                const seconds = playoutTime / 1000;
-                return Math.floor(this.sampleRate * seconds);
-            }
-            totalDuration() {
-                let duration = 0;
-                for (const effect of this.effectBuffer)
-                    duration += effect.duration;
-                return duration;
-            }
-        }
-        music.SoundEmojiSynthesizer = SoundEmojiSynthesizer;
-    })(music = pxsim.music || (pxsim.music = {}));
-})(pxsim || (pxsim = {}));
-/**
- * Adapted from lancaster-university/codal-microbit-v2
- * https://github.com/lancaster-university/codal-microbit-v2/blob/master/source/SoundExpressions.cpp#L286
- */
-var pxsim;
-(function (pxsim) {
-    var music;
-    (function (music) {
-        var builtin;
-        (function (builtin) {
-            const giggle = "giggle";
-            const giggleData = "010230988019008440044008881023001601003300240000000000000000000000000000,110232570087411440044008880352005901003300010000000000000000010000000000,310232729021105440288908880091006300000000240700020000000000003000000000,310232729010205440288908880091006300000000240700020000000000003000000000,310232729011405440288908880091006300000000240700020000000000003000000000";
-            const happy = "happy";
-            const happyData = "010231992066911440044008880262002800001800020500000000000000010000000000,002322129029508440240408880000000400022400110000000000000000007500000000,000002129029509440240408880145000400022400110000000000000000007500000000";
-            const hello = "hello";
-            const helloData = "310230673019702440118708881023012800000000240000000000000000000000000000,300001064001602440098108880000012800000100040000000000000000000000000000,310231064029302440098108881023012800000100040000000000000000000000000000";
-            const mysterious = "mysterious";
-            const mysteriousData = "400002390033100440240408880477000400022400110400000000000000008000000000,405512845385000440044008880000012803010500160000000000000000085000500015";
-            const sad = "sad";
-            const sadData = "310232226070801440162408881023012800000100240000000000000000000000000000,310231623093602440093908880000012800000100240000000000000000000000000000";
-            const slide = "slide";
-            const slideData = "105202325022302440240408881023012801020000110400000000000000010000000000,010232520091002440044008881023012801022400110400000000000000010000000000";
-            const soaring = "soaring";
-            const soaringData = "210234009530905440599908881023002202000400020250000000000000020000000000,402233727273014440044008880000003101024400030000000000000000000000000000";
-            const spring = "spring";
-            const springData = "306590037116312440058708880807003400000000240000000000000000050000000000,010230037116313440058708881023003100000000240000000000000000050000000000";
-            const twinkle = "twinkle";
-            const twinkleData = "010180007672209440075608880855012800000000240000000000000000000000000000";
-            const yawn = "yawn";
-            const yawnData = "200002281133202440150008881023012801024100240400030000000000010000000000,005312520091002440044008880636012801022400110300000000000000010000000000,008220784019008440044008880681001600005500240000000000000000005000000000,004790784019008440044008880298001600000000240000000000000000005000000000,003210784019008440044008880108001600003300080000000000000000005000000000";
-            function lookupBuiltIn(sound) {
-                if (sound == giggle)
-                    return giggleData;
-                if (sound == happy)
-                    return happyData;
-                if (sound == hello)
-                    return helloData;
-                if (sound == mysterious)
-                    return mysteriousData;
-                if (sound == sad)
-                    return sadData;
-                if (sound == slide)
-                    return slideData;
-                if (sound == soaring)
-                    return soaringData;
-                if (sound == spring)
-                    return springData;
-                if (sound == twinkle)
-                    return twinkleData;
-                if (sound == yawn)
-                    return yawnData;
-                return sound;
-            }
-            builtin.lookupBuiltIn = lookupBuiltIn;
-        })(builtin = music.builtin || (music.builtin = {}));
-    })(music = pxsim.music || (pxsim.music = {}));
-})(pxsim || (pxsim = {}));
-/**
- * Adapted from lancaster-university/codal-core
- * https://github.com/lancaster-university/codal-core/blob/master/source/streams/Synthesizer.cpp#L54
- */
-var pxsim;
-(function (pxsim) {
-    var music;
-    (function (music) {
-        var Synthesizer;
-        (function (Synthesizer) {
-            const sineTone = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 11, 11, 12, 13, 13, 14, 15, 16, 16, 17, 18, 19, 20, 21, 22, 22, 23, 24, 25, 26, 27, 28, 29, 30, 32, 33, 34, 35, 36, 37, 38, 40, 41, 42, 43, 45, 46, 47, 49, 50, 51, 53, 54, 56, 57, 58, 60, 61, 63, 64, 66, 68, 69, 71, 72, 74, 76, 77, 79, 81, 82, 84, 86, 87, 89, 91, 93, 95, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 141, 143, 145, 147, 149, 152, 154, 156, 158, 161, 163, 165, 167, 170, 172, 175, 177, 179, 182, 184, 187, 189, 191, 194, 196, 199, 201, 204, 206, 209, 211, 214, 216, 219, 222, 224, 227, 229, 232, 235, 237, 240, 243, 245, 248, 251, 253, 256, 259, 262, 264, 267, 270, 273, 275, 278, 281, 284, 287, 289, 292, 295, 298, 301, 304, 307, 309, 312, 315, 318, 321, 324, 327, 330, 333, 336, 339, 342, 345, 348, 351, 354, 357, 360, 363, 366, 369, 372, 375, 378, 381, 384, 387, 390, 393, 396, 399, 402, 405, 408, 411, 414, 417, 420, 424, 427, 430, 433, 436, 439, 442, 445, 448, 452, 455, 458, 461, 464, 467, 470, 473, 477, 480, 483, 486, 489, 492, 495, 498, 502, 505, 508, 511, 514, 517, 520, 524, 527, 530, 533, 536, 539, 542, 545, 549, 552, 555, 558, 561, 564, 567, 570, 574, 577, 580, 583, 586, 589, 592, 595, 598, 602, 605, 608, 611, 614, 617, 620, 623, 626, 629, 632, 635, 638, 641, 644, 647, 650, 653, 656, 659, 662, 665, 668, 671, 674, 677, 680, 683, 686, 689, 692, 695, 698, 701, 704, 707, 710, 713, 715, 718, 721, 724, 727, 730, 733, 735, 738, 741, 744, 747, 749, 752, 755, 758, 760, 763, 766, 769, 771, 774, 777, 779, 782, 785, 787, 790, 793, 795, 798, 800, 803, 806, 808, 811, 813, 816, 818, 821, 823, 826, 828, 831, 833, 835, 838, 840, 843, 845, 847, 850, 852, 855, 857, 859, 861, 864, 866, 868, 870, 873, 875, 877, 879, 881, 884, 886, 888, 890, 892, 894, 896, 898, 900, 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922, 924, 926, 927, 929, 931, 933, 935, 936, 938, 940, 941, 943, 945, 946, 948, 950, 951, 953, 954, 956, 958, 959, 961, 962, 964, 965, 966, 968, 969, 971, 972, 973, 975, 976, 977, 979, 980, 981, 982, 984, 985, 986, 987, 988, 989, 990, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1006, 1007, 1008, 1009, 1009, 1010, 1011, 1011, 1012, 1013, 1013, 1014, 1014, 1015, 1015, 1016, 1016, 1017, 1017, 1018, 1018, 1019, 1019, 1019, 1020, 1020, 1020, 1021, 1021, 1021, 1021, 1022, 1022, 1022, 1022, 1022, 1022, 1022, 1022, 1022, 1022, 1023, 1022];
-            const TONE_WIDTH = 1024;
-            function SineTone(arg, position) {
-                position |= 0;
-                let off = TONE_WIDTH - position;
-                if (off < TONE_WIDTH / 2)
-                    position = off;
-                return sineTone[position];
-            }
-            Synthesizer.SineTone = SineTone;
-            function SawtoothTone(arg, position) {
-                return position;
-            }
-            Synthesizer.SawtoothTone = SawtoothTone;
-            function TriangleTone(arg, position) {
-                return position < 512 ? position * 2 : (1023 - position) * 2;
-            }
-            Synthesizer.TriangleTone = TriangleTone;
-            function NoiseTone(arg, position) {
-                // deterministic, semi-random noise
-                let mult = arg[0];
-                if (mult == 0)
-                    mult = 7919;
-                return (position * mult) & 1023;
-            }
-            Synthesizer.NoiseTone = NoiseTone;
-            function SquareWaveTone(arg, position) {
-                return position < 512 ? 1023 : 0;
-            }
-            Synthesizer.SquareWaveTone = SquareWaveTone;
-        })(Synthesizer = music.Synthesizer || (music.Synthesizer = {}));
-    })(music = pxsim.music || (pxsim.music = {}));
-})(pxsim || (pxsim = {}));
-/**
- * Adapted from lancaster-university/codal-microbit-v2
- * https://github.com/lancaster-university/codal-microbit-v2/blob/master/source/SoundSynthesizerEffects.cpp
- */
-var pxsim;
-(function (pxsim) {
-    var music;
-    (function (music) {
-        var SoundSynthesizerEffects;
-        (function (SoundSynthesizerEffects) {
-            /*
-             * Definitions of standard progressions.
-             */
-            /**
-             * Root Frequency Interpolation Effect Functions
-             */
-            function noInterpolation(synth, context) {
-            }
-            SoundSynthesizerEffects.noInterpolation = noInterpolation;
-            // Linear interpolate function.
-            // parameter[0]: end frequency
-            function linearInterpolation(synth, context) {
-                let interval = (context.parameter[0] - synth.effect.frequency) / context.steps;
-                synth.frequency = synth.effect.frequency + interval * context.step;
-            }
-            SoundSynthesizerEffects.linearInterpolation = linearInterpolation;
-            // Linear interpolate function.
-            // parameter[0]: end frequency
-            function logarithmicInterpolation(synth, context) {
-                synth.frequency = synth.effect.frequency + (Math.log10(context.step) * (context.parameter[0] - synth.effect.frequency) / 1.95);
-            }
-            SoundSynthesizerEffects.logarithmicInterpolation = logarithmicInterpolation;
-            // Curve interpolate function
-            // parameter[0]: end frequency
-            function curveInterpolation(synth, context) {
-                synth.frequency = (Math.sin(context.step * 3.12159 / 180.0) * (context.parameter[0] - synth.effect.frequency) + synth.effect.frequency);
-            }
-            SoundSynthesizerEffects.curveInterpolation = curveInterpolation;
-            // Cosine interpolate function
-            // parameter[0]: end frequency
-            function slowVibratoInterpolation(synth, context) {
-                synth.frequency = Math.sin(context.step / 10) * context.parameter[0] + synth.effect.frequency;
-            }
-            SoundSynthesizerEffects.slowVibratoInterpolation = slowVibratoInterpolation;
-            //warble function
-            // parameter[0]: end frequency
-            function warbleInterpolation(synth, context) {
-                synth.frequency = (Math.sin(context.step) * (context.parameter[0] - synth.effect.frequency) + synth.effect.frequency);
-            }
-            SoundSynthesizerEffects.warbleInterpolation = warbleInterpolation;
-            // Vibrato function
-            // parameter[0]: end frequency
-            function vibratoInterpolation(synth, context) {
-                synth.frequency = synth.effect.frequency + Math.sin(context.step) * context.parameter[0];
-            }
-            SoundSynthesizerEffects.vibratoInterpolation = vibratoInterpolation;
-            // Exponential rising function
-            // parameter[0]: end frequency
-            function exponentialRisingInterpolation(synth, context) {
-                synth.frequency = synth.effect.frequency + Math.sin(0.01745329 * context.step) * context.parameter[0];
-            }
-            SoundSynthesizerEffects.exponentialRisingInterpolation = exponentialRisingInterpolation;
-            // Exponential falling function
-            function exponentialFallingInterpolation(synth, context) {
-                synth.frequency = synth.effect.frequency + Math.cos(0.01745329 * context.step) * context.parameter[0];
-            }
-            SoundSynthesizerEffects.exponentialFallingInterpolation = exponentialFallingInterpolation;
-            // Argeppio functions
-            function appregrioAscending(synth, context) {
-                synth.frequency = music.MusicalProgressions.calculateFrequencyFromProgression(synth.effect.frequency, context.parameter_p[0], context.step);
-            }
-            SoundSynthesizerEffects.appregrioAscending = appregrioAscending;
-            function appregrioDescending(synth, context) {
-                synth.frequency = music.MusicalProgressions.calculateFrequencyFromProgression(synth.effect.frequency, context.parameter_p[0], context.steps - context.step - 1);
-            }
-            SoundSynthesizerEffects.appregrioDescending = appregrioDescending;
-            /**
-             * Frequency Delta effects
-             */
-            // Frequency vibrato function
-            // parameter[0]: vibrato frequency multiplier
-            function frequencyVibratoEffect(synth, context) {
-                if (context.step == 0)
-                    return;
-                if (context.step % 2 == 0)
-                    synth.frequency /= context.parameter[0];
-                else
-                    synth.frequency *= context.parameter[0];
-            }
-            SoundSynthesizerEffects.frequencyVibratoEffect = frequencyVibratoEffect;
-            // Volume vibrato function
-            // parameter[0]: vibrato volume multiplier
-            function volumeVibratoEffect(synth, context) {
-                if (context.step == 0)
-                    return;
-                if (context.step % 2 == 0)
-                    synth.volume /= context.parameter[0];
-                else
-                    synth.volume *= context.parameter[0];
-            }
-            SoundSynthesizerEffects.volumeVibratoEffect = volumeVibratoEffect;
-            /**
-             * Volume Delta effects
-             */
-            /** Simple ADSR enveleope effect.
-             * parameter[0]: Centre volume
-             * parameter[1]: End volume
-             * effect.volume: start volume
-             */
-            function adsrVolumeEffect(synth, context) {
-                let halfSteps = context.steps * 0.5;
-                if (context.step <= halfSteps) {
-                    let delta = (context.parameter[0] - synth.effect.volume) / halfSteps;
-                    synth.volume = synth.effect.volume + context.step * delta;
-                }
-                else {
-                    let delta = (context.parameter[1] - context.parameter[0]) / halfSteps;
-                    synth.volume = context.parameter[0] + (context.step - halfSteps) * delta;
-                }
-            }
-            SoundSynthesizerEffects.adsrVolumeEffect = adsrVolumeEffect;
-            /**
-             * Simple volume ramp effect
-             * parameter[0]: End volume
-             * effect.volume: start volume
-             */
-            function volumeRampEffect(synth, context) {
-                let delta = (context.parameter[0] - synth.effect.volume) / context.steps;
-                synth.volume = synth.effect.volume + context.step * delta;
-            }
-            SoundSynthesizerEffects.volumeRampEffect = volumeRampEffect;
-        })(SoundSynthesizerEffects = music.SoundSynthesizerEffects || (music.SoundSynthesizerEffects = {}));
-    })(music = pxsim.music || (pxsim.music = {}));
-})(pxsim || (pxsim = {}));
-var pxsim;
-(function (pxsim) {
-    var music;
-    (function (music) {
-        let synth;
-        let soundPromise;
         //%
         function __playSoundExpression(notes, waitTillDone) {
-            const cb = pxsim.getResume();
-            const b = pxsim.board();
-            // v2 only...
-            b.ensureHardwareVersion(2);
-            if (!synth)
-                synth = new music.SoundEmojiSynthesizer(0);
-            if (!soundPromise)
-                soundPromise = Promise.resolve();
-            soundPromise = soundPromise.then(() => {
-                notes = music.builtin.lookupBuiltIn(notes);
-                const soundEffects = parseSoundEffects(notes);
-                synth.play(soundEffects);
-                let cancelled = false;
-                return Promise.race([
-                    delayAsync(synth.totalDuration())
-                        .then(() => {
-                        // If safari didn't allow the sound to play for some reason,
-                        // it will get delayed until the user does something that
-                        // unmutes it. make sure we cancel it so that it doesn't
-                        // play long after it was supposed to
-                        cancelled = true;
-                    }),
-                    pxsim.AudioContextManager.playPCMBufferStreamAsync(() => {
-                        if (!synth.effect)
-                            return undefined;
-                        const buff = synth.pull();
-                        const arr = new Float32Array(buff.length);
-                        for (let i = 0; i < buff.length; i++) {
-                            // Buffer is (0, 1023) we need to map it to (-1, 1)
-                            arr[i] = ((buff[i] - 512) / 512);
-                        }
-                        return arr;
-                    }, synth.sampleRate, 0.03, () => cancelled)
-                ]);
-            });
-            if (!waitTillDone)
-                cb();
-            else
-                soundPromise = soundPromise.then(cb);
+            notes = lookupBuiltIn(notes);
+            pxsim.codal.music.__playSoundExpression(notes, waitTillDone);
         }
         music.__playSoundExpression = __playSoundExpression;
         function __stopSoundExpressions() {
             pxsim.AudioContextManager.stopAll();
         }
         music.__stopSoundExpressions = __stopSoundExpressions;
-        /**
-         * Adapted from lancaster-university/codal-microbit-v2
-         * https://github.com/lancaster-university/codal-microbit-v2/blob/master/source/SoundExpressions.cpp
-         */
-        function parseSoundEffects(notes) {
-            // https://github.com/lancaster-university/codal-microbit-v2/blob/master/source/SoundExpressions.cpp#L57
-            // 72 characters of sound data comma separated
-            const charsPerEffect = 72;
-            const effectCount = Math.floor((notes.length + 1) / (charsPerEffect + 1));
-            const expectedLength = effectCount * (charsPerEffect + 1) - 1;
-            if (notes.length != expectedLength) {
-                return [];
-            }
-            const soundEffects = [];
-            for (let i = 0; i < effectCount; ++i) {
-                const start = i * charsPerEffect + i;
-                if (start > 0 && notes[start - 1] != ',') {
-                    return [];
-                }
-                const effect = blankSoundEffect();
-                if (!parseSoundExpression(notes.substr(start), effect)) {
-                    return [];
-                }
-                soundEffects.push(effect);
-            }
-            return soundEffects;
-        }
-        function parseSoundExpression(soundChars, fx) {
-            // https://github.com/lancaster-university/codal-microbit-v2/blob/master/source/SoundExpressions.cpp#L115
-            // Encoded as a sequence of zero padded decimal strings.
-            // This encoding is worth reconsidering if we can!
-            // The ADSR effect (and perhaps others in future) has two parameters which cannot be expressed.
-            // 72 chars total
-            //  [0] 0-4 wave
-            let wave = parseInt(soundChars.substr(0, 1));
-            //  [1] 0000-1023 volume
-            let effectVolume = parseInt(soundChars.substr(1, 4));
-            //  [5] 0000-9999 frequency
-            let frequency = parseInt(soundChars.substr(5, 4));
-            //  [9] 0000-9999 duration
-            let duration = parseInt(soundChars.substr(9, 4));
-            // [13] 00 shape (specific known values)
-            let shape = parseInt(soundChars.substr(13, 2));
-            // [15] XXX unused/bug. This was startFrequency but we use frequency above.
-            // [18] 0000-9999 end frequency
-            let endFrequency = parseInt(soundChars.substr(18, 4));
-            // [22] XXXX unused. This was start volume but we use volume above.
-            // [26] 0000-1023 end volume
-            let endVolume = parseInt(soundChars.substr(26, 4));
-            // [30] 0000-9999 steps
-            let steps = parseInt(soundChars.substr(30, 4));
-            // [34] 00-03 fx choice
-            let fxChoice = parseInt(soundChars.substr(34, 2));
-            // [36] 0000-9999 fxParam
-            let fxParam = parseInt(soundChars.substr(36, 4));
-            // [40] 0000-9999 fxnSteps
-            let fxnSteps = parseInt(soundChars.substr(40, 4));
-            // Details that encoded randomness to be applied when frame is used:
-            // Can the randomness cause any parameters to go out of range?
-            // [44] 0000-9999 frequency random
-            frequency = applyRandom(frequency, parseInt(soundChars.substr(44, 4)));
-            // [48] 0000-9999 end frequency random
-            endFrequency = applyRandom(endFrequency, parseInt(soundChars.substr(48, 4)));
-            // [52] 0000-9999 volume random
-            effectVolume = applyRandom(effectVolume, parseInt(soundChars.substr(52, 4)));
-            // [56] 0000-9999 end volume random
-            endVolume = applyRandom(endVolume, parseInt(soundChars.substr(56, 4)));
-            // [60] 0000-9999 duration random
-            duration = applyRandom(duration, parseInt(soundChars.substr(60, 4)));
-            // [64] 0000-9999 fxParamRandom
-            fxParam = applyRandom(fxParam, parseInt(soundChars.substr(64, 4)));
-            // [68] 0000-9999 fxnStepsRandom
-            fxnSteps = applyRandom(fxnSteps, parseInt(soundChars.substr(68, 4)));
-            if (frequency == -1 || endFrequency == -1 || effectVolume == -1 || endVolume == -1 || duration == -1 || fxParam == -1 || fxnSteps == -1) {
-                return false;
-            }
-            let volumeScaleFactor = 1;
-            switch (wave) {
-                case 0:
-                    fx.tone.tonePrint = music.Synthesizer.SineTone;
-                    break;
-                case 1:
-                    fx.tone.tonePrint = music.Synthesizer.SawtoothTone;
-                    break;
-                case 2:
-                    fx.tone.tonePrint = music.Synthesizer.TriangleTone;
-                    break;
-                case 3:
-                    fx.tone.tonePrint = music.Synthesizer.SquareWaveTone;
-                    break;
-                case 4:
-                    fx.tone.tonePrint = music.Synthesizer.NoiseTone;
-                    break;
-            }
-            fx.frequency = frequency;
-            fx.duration = duration;
-            fx.effects[0].steps = steps;
-            switch (shape) {
-                case 0:
-                    fx.effects[0].effect = music.SoundSynthesizerEffects.noInterpolation;
-                    break;
-                case 1:
-                    fx.effects[0].effect = music.SoundSynthesizerEffects.linearInterpolation;
-                    fx.effects[0].parameter[0] = endFrequency;
-                    break;
-                case 2:
-                    fx.effects[0].effect = music.SoundSynthesizerEffects.curveInterpolation;
-                    fx.effects[0].parameter[0] = endFrequency;
-                    break;
-                case 5:
-                    fx.effects[0].effect = music.SoundSynthesizerEffects.exponentialRisingInterpolation;
-                    fx.effects[0].parameter[0] = endFrequency;
-                    break;
-                case 6:
-                    fx.effects[0].effect = music.SoundSynthesizerEffects.exponentialFallingInterpolation;
-                    fx.effects[0].parameter[0] = endFrequency;
-                    break;
-                case 8: // various ascending scales - see next switch
-                case 10:
-                case 12:
-                case 14:
-                case 16:
-                    fx.effects[0].effect = music.SoundSynthesizerEffects.appregrioAscending;
-                    break;
-                case 9: // various descending scales - see next switch
-                case 11:
-                case 13:
-                case 15:
-                case 17:
-                    fx.effects[0].effect = music.SoundSynthesizerEffects.appregrioDescending;
-                    break;
-                case 18:
-                    fx.effects[0].effect = music.SoundSynthesizerEffects.logarithmicInterpolation;
-                    break;
-            }
-            // Scale
-            switch (shape) {
-                case 8:
-                case 9:
-                    fx.effects[0].parameter_p[0] = music.MusicalProgressions.majorScale;
-                    break;
-                case 10:
-                case 11:
-                    fx.effects[0].parameter_p[0] = music.MusicalProgressions.minorScale;
-                    break;
-                case 12:
-                case 13:
-                    fx.effects[0].parameter_p[0] = music.MusicalProgressions.diminished;
-                    break;
-                case 14:
-                case 15:
-                    fx.effects[0].parameter_p[0] = music.MusicalProgressions.chromatic;
-                    break;
-                case 16:
-                case 17:
-                    fx.effects[0].parameter_p[0] = music.MusicalProgressions.wholeTone;
-                    break;
-            }
-            // Volume envelope
-            let effectVolumeFloat = CLAMP(0, effectVolume, 1023) / 1023.0;
-            let endVolumeFloat = CLAMP(0, endVolume, 1023) / 1023.0;
-            fx.volume = volumeScaleFactor * effectVolumeFloat;
-            fx.effects[1].effect = music.SoundSynthesizerEffects.volumeRampEffect;
-            fx.effects[1].steps = 36;
-            fx.effects[1].parameter[0] = volumeScaleFactor * endVolumeFloat;
-            // Vibrato effect
-            // Steps need to be spread across duration evenly.
-            let normalizedFxnSteps = (fx.duration / 10000) * fxnSteps;
-            switch (fxChoice) {
-                case 1:
-                    fx.effects[2].steps = normalizedFxnSteps;
-                    fx.effects[2].effect = music.SoundSynthesizerEffects.frequencyVibratoEffect;
-                    fx.effects[2].parameter[0] = fxParam;
-                    break;
-                case 2:
-                    fx.effects[2].steps = normalizedFxnSteps;
-                    fx.effects[2].effect = music.SoundSynthesizerEffects.volumeVibratoEffect;
-                    fx.effects[2].parameter[0] = fxParam;
-                    break;
-                case 3:
-                    fx.effects[2].steps = normalizedFxnSteps;
-                    fx.effects[2].effect = music.SoundSynthesizerEffects.warbleInterpolation;
-                    fx.effects[2].parameter[0] = fxParam;
-                    break;
-            }
-            return true;
-        }
-        music.parseSoundExpression = parseSoundExpression;
-        function random(max) {
-            return Math.floor(Math.random() * max);
-        }
-        function CLAMP(min, value, max) {
-            return Math.min(max, Math.max(min, value));
-        }
-        function applyRandom(value, rand) {
-            if (value < 0 || rand < 0) {
-                return -1;
-            }
-            const delta = random(rand * 2 + 1) - rand;
-            return Math.abs(value + delta);
-        }
-        function blankSoundEffect() {
-            const res = {
-                frequency: 0,
-                volume: 1,
-                duration: 0,
-                tone: {
-                    tonePrint: undefined,
-                    parameter: [0]
-                },
-                effects: []
-            };
-            for (let i = 0; i < music.EMOJI_SYNTHESIZER_TONE_EFFECTS; i++) {
-                res.effects.push({
-                    effect: undefined,
-                    step: 0,
-                    steps: 0,
-                    parameter: [],
-                    parameter_p: []
-                });
-            }
-            return res;
-        }
-        function delayAsync(millis) {
-            return new Promise(resolve => setTimeout(resolve, millis));
+        const giggle = "giggle";
+        const giggleData = "010230988019008440044008881023001601003300240000000000000000000000000000,110232570087411440044008880352005901003300010000000000000000010000000000,310232729021105440288908880091006300000000240700020000000000003000000000,310232729010205440288908880091006300000000240700020000000000003000000000,310232729011405440288908880091006300000000240700020000000000003000000000";
+        const happy = "happy";
+        const happyData = "010231992066911440044008880262002800001800020500000000000000010000000000,002322129029508440240408880000000400022400110000000000000000007500000000,000002129029509440240408880145000400022400110000000000000000007500000000";
+        const hello = "hello";
+        const helloData = "310230673019702440118708881023012800000000240000000000000000000000000000,300001064001602440098108880000012800000100040000000000000000000000000000,310231064029302440098108881023012800000100040000000000000000000000000000";
+        const mysterious = "mysterious";
+        const mysteriousData = "400002390033100440240408880477000400022400110400000000000000008000000000,405512845385000440044008880000012803010500160000000000000000085000500015";
+        const sad = "sad";
+        const sadData = "310232226070801440162408881023012800000100240000000000000000000000000000,310231623093602440093908880000012800000100240000000000000000000000000000";
+        const slide = "slide";
+        const slideData = "105202325022302440240408881023012801020000110400000000000000010000000000,010232520091002440044008881023012801022400110400000000000000010000000000";
+        const soaring = "soaring";
+        const soaringData = "210234009530905440599908881023002202000400020250000000000000020000000000,402233727273014440044008880000003101024400030000000000000000000000000000";
+        const spring = "spring";
+        const springData = "306590037116312440058708880807003400000000240000000000000000050000000000,010230037116313440058708881023003100000000240000000000000000050000000000";
+        const twinkle = "twinkle";
+        const twinkleData = "010180007672209440075608880855012800000000240000000000000000000000000000";
+        const yawn = "yawn";
+        const yawnData = "200002281133202440150008881023012801024100240400030000000000010000000000,005312520091002440044008880636012801022400110300000000000000010000000000,008220784019008440044008880681001600005500240000000000000000005000000000,004790784019008440044008880298001600000000240000000000000000005000000000,003210784019008440044008880108001600003300080000000000000000005000000000";
+        function lookupBuiltIn(sound) {
+            if (sound == giggle)
+                return giggleData;
+            if (sound == happy)
+                return happyData;
+            if (sound == hello)
+                return helloData;
+            if (sound == mysterious)
+                return mysteriousData;
+            if (sound == sad)
+                return sadData;
+            if (sound == slide)
+                return slideData;
+            if (sound == soaring)
+                return soaringData;
+            if (sound == spring)
+                return springData;
+            if (sound == twinkle)
+                return twinkleData;
+            if (sound == yawn)
+                return yawnData;
+            return sound;
         }
     })(music = pxsim.music || (pxsim.music = {}));
 })(pxsim || (pxsim = {}));
@@ -3817,7 +3180,7 @@ path.sim-board {
                     let pt = this.element.createSVGPoint();
                     pxsim.svg.buttonEvents(this.head, (ev) => {
                         let cur = pxsim.svg.cursorPoint(pt, this.element, ev);
-                        state.compassState.heading = 360 - (Math.floor(Math.atan2(cur.y - yc, cur.x - xc) * 180 / Math.PI) + 90) - 360;
+                        state.compassState.heading = Math.floor(Math.atan2(cur.y - yc, cur.x - xc) * 180 / Math.PI) + 90;
                         if (state.compassState.heading < 0)
                             state.compassState.heading += 360;
                         this.updateHeading();
@@ -3826,7 +3189,7 @@ path.sim-board {
                 }
                 let txt = state.compassState.heading.toString() + "°";
                 if (txt != this.headText.textContent) {
-                    pxsim.svg.rotateElement(this.head, xc, yc, 360 - state.compassState.heading - 180);
+                    pxsim.svg.rotateElement(this.head, xc, yc, state.compassState.heading - 180);
                     this.headText.textContent = txt;
                     if (this.props.runtime)
                         this.props.runtime.environmentGlobals[pxsim.localization.lf("heading")] = state.compassState.heading;