pxt-common-packages 10.4.4 → 10.4.5

package/libs/lcd/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P48826(s) {
+function _main___P48860(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___49069 = (undefined);
-    globals._pollEventQueue___49082 = (undefined);
+    globals._intervals___49103 = (undefined);
+    globals._pollEventQueue___49116 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P48826.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"characterlcd.ts","functionName":"<main>","argumentNames":[]}
-_main___P48826.continuations = [  ]
+_main___P48860.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"characterlcd.ts","functionName":"<main>","argumentNames":[]}
+_main___P48860.continuations = [  ]
 
-function _main___P48826_mk(s) {
+function _main___P48860_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P48826, depth: s.depth + 1,
+        parent: s, fn: _main___P48860, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P48826_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P48826
+return _main___P48860
 })

package/libs/light-spectrum-sensor/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P98810(s) {
+function _main___P98912(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___99053 = (undefined);
-    globals._pollEventQueue___99066 = (undefined);
+    globals._intervals___99155 = (undefined);
+    globals._pollEventQueue___99168 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P98810.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"tsl2591.ts","functionName":"<main>","argumentNames":[]}
-_main___P98810.continuations = [  ]
+_main___P98912.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"tsl2591.ts","functionName":"<main>","argumentNames":[]}
+_main___P98912.continuations = [  ]
 
-function _main___P98810_mk(s) {
+function _main___P98912_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P98810, depth: s.depth + 1,
+        parent: s, fn: _main___P98912, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P98810_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P98810
+return _main___P98912
 })

package/libs/lora/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P60128(s) {
+function _main___P60162(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___60371 = (undefined);
-    globals._pollEventQueue___60384 = (undefined);
+    globals._intervals___60405 = (undefined);
+    globals._pollEventQueue___60418 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P60128.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"lora.ts","functionName":"<main>","argumentNames":[]}
-_main___P60128.continuations = [  ]
+_main___P60162.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"lora.ts","functionName":"<main>","argumentNames":[]}
+_main___P60162.continuations = [  ]
 
-function _main___P60128_mk(s) {
+function _main___P60162_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P60128, depth: s.depth + 1,
+        parent: s, fn: _main___P60162, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P60128_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P60128
+return _main___P60162
 })

package/libs/matrix-keypad/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P192302(s) {
+function _main___P192540(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___192545 = (undefined);
-    globals._pollEventQueue___192558 = (undefined);
+    globals._intervals___192783 = (undefined);
+    globals._pollEventQueue___192796 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P192302.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"keypad.ts","functionName":"<main>","argumentNames":[]}
-_main___P192302.continuations = [  ]
+_main___P192540.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"keypad.ts","functionName":"<main>","argumentNames":[]}
+_main___P192540.continuations = [  ]
 
-function _main___P192302_mk(s) {
+function _main___P192540_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P192302, depth: s.depth + 1,
+        parent: s, fn: _main___P192540, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P192302_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P192302
+return _main___P192540
 })

package/libs/mixer/instrument.ts

@@ -133,18 +133,36 @@ namespace music.sequencer {
         }
 
         play(playbackMode: PlaybackMode) {
-            if (currentSequencer) currentSequencer.stop();
-            currentSequencer = new sequencer.Sequencer(this);
+            if (control.deviceDalVersion() === "sim") {
+                const seq = new _SimulatorSequencer();
 
-            if (playbackMode === PlaybackMode.UntilDone) {
-                currentSequencer.start(false);
-                pause(this.measures * this.beatsPerMeasure * this.beatsPerMinute * 60 * 1000)
-            }
-            else if (playbackMode === PlaybackMode.InBackground) {
-                currentSequencer.start(false);
+                if (playbackMode === PlaybackMode.UntilDone) {
+                    seq.play(this.buf, false);
+
+                    pauseUntil(() => seq.state() === "stop");
+                }
+                else if (playbackMode === PlaybackMode.InBackground) {
+                    seq.play(this.buf, false);
+                }
+                else {
+                    seq.play(this.buf, true);
+                }
             }
             else {
-                currentSequencer.start(true);
+                if (currentSequencer) currentSequencer.stop();
+                currentSequencer = new sequencer.Sequencer(this);
+
+                if (playbackMode === PlaybackMode.UntilDone) {
+                    let seq = currentSequencer;
+                    currentSequencer.start(false);
+                    pauseUntil(() => !seq.isRunning);
+                }
+                else if (playbackMode === PlaybackMode.InBackground) {
+                    currentSequencer.start(false);
+                }
+                else {
+                    currentSequencer.start(true);
+                }
             }
         }
     }
@@ -817,5 +835,6 @@ namespace music.sequencer {
             currentSequencer.stop();
             currentSequencer = undefined;
         }
+        _stopAllSimSequencers();
     }
 }

package/libs/mixer/melody.cpp

@@ -426,6 +426,49 @@ WSynthesizer::WSynthesizer() : upstream(NULL), out(*this) {
     PXT_REGISTER_RESET(stopPlaying);
 }
 
+//% promise
+int _createSequencer() {
+    return 0;
+}
+
+//%
+String _sequencerState(int id) {
+    return NULL;
+}
+
+//%
+int _sequencerCurrentTick(int id) {
+    return 0;
+}
+
+//%
+void _sequencerPlaySong(int id, Buffer buf, bool loop) {
+}
+
+//%
+void _sequencerStop(int id) {
+}
+
+//%
+void _sequencerSetVolume(int id, int volume) {
+}
+
+//%
+void _sequencerSetVolumeForAll(int volume) {
+}
+
+//%
+void _sequencerSetTrackVolume(int id, int trackIndex, int volume) {
+}
+
+//%
+void _sequencerSetDrumTrackVolume(int id, int trackIndex, int drumIndex, int volume) {
+}
+
+//%
+void _sequencerDispose(int id) {
+}
+
 } // namespace music
 
 namespace pxt {

package/libs/mixer/sequencer.ts

@@ -1,4 +1,9 @@
 namespace music.sequencer {
+    const SEQUENCER_STOP_MESSAGE = 3243;
+    const SEQUENCER_TICK_MESSAGE = 3244;
+    const SEQUENCER_STATE_CHANGE_MESSAGE = 3245;
+    const SEQUENCER_LOOPED_MESSAGE = 3246;
+
     export class Sequencer {
         currentTick: number;
         isPlaying: boolean;
@@ -85,4 +90,115 @@ namespace music.sequencer {
             }
         }
     }
+
+    let activeSimSequencers: _SimulatorSequencer[];
+    export function _stopAllSimSequencers() {
+        if (activeSimSequencers) {
+            for (const seq of activeSimSequencers) {
+                seq.stop();
+                seq.dispose();
+            }
+            activeSimSequencers = [];
+        }
+    }
+
+    // Simulator only! Does nothing on hardware
+    export class _SimulatorSequencer {
+        protected id: number;
+
+        constructor() {
+            if (!activeSimSequencers) activeSimSequencers = [];
+            activeSimSequencers.push(this);
+            this.id = _createSequencer();
+            this.setVolume(music.volume());
+        }
+
+        play(song: Buffer, loop: boolean) {
+            this.setVolume(music.volume());
+            _sequencerPlaySong(this.id, song, loop)
+        }
+
+        stop() {
+            _sequencerStop(this.id);
+        }
+
+        setVolume(volume: number) {
+            _sequencerSetVolume(this.id, volume);
+        }
+
+        setTrackVolume(trackIndex: number, volume: number) {
+            _sequencerSetTrackVolume(this.id, trackIndex, volume)
+        }
+
+        setDrumTrackVolume(trackIndex: number, drumIndex: number, volume: number) {
+            _sequencerSetDrumTrackVolume(this.id, drumIndex, trackIndex, volume)
+        }
+
+        state() {
+            return _sequencerState(this.id) || "stop";
+        }
+
+        currentTick() {
+            return _sequencerCurrentTick(this.id);
+        }
+
+        dispose() {
+            _sequencerDispose(this.id);
+        }
+
+        onTick(handler: (tick: number) => void) {
+            control.onEvent(SEQUENCER_TICK_MESSAGE, this.id, () => {
+                handler(this.currentTick());
+            });
+        }
+
+        onStateChange(handler: (state: string) => void) {
+            control.onEvent(SEQUENCER_STATE_CHANGE_MESSAGE, this.id, () => {
+                handler(this.state());
+            });
+        }
+
+        onStop(handler: () => void) {
+            control.onEvent(SEQUENCER_STOP_MESSAGE, this.id, () => {
+                handler();
+            });
+        }
+
+        onLooped(handler: () => void) {
+            control.onEvent(SEQUENCER_LOOPED_MESSAGE, this.id, () => {
+                handler();
+            });
+        }
+    }
+
+    //% promise
+    //% shim=music::_createSequencer
+    declare function _createSequencer(): number
+
+    //% shim=music::_sequencerState
+    declare function _sequencerState(id: number): string;
+
+    //% shim=music::_sequencerCurrentTick
+    declare function _sequencerCurrentTick(id: number): number;
+
+    //% shim=music::_sequencerPlaySong
+    declare function _sequencerPlaySong(id: number, song: Buffer, loop: boolean): void;
+
+    //% shim=music::_sequencerStop
+    declare function _sequencerStop(id: number): void;
+
+    //% shim=music::_sequencerSetVolume
+    declare function _sequencerSetVolume(id: number, volume: number): void;
+
+    //% shim=music::_sequencerSetVolumeForAll
+    declare function _sequencerSetVolumeForAll(volume: number): void;
+
+    //% shim=music::_sequencerSetTrackVolume
+    declare function _sequencerSetTrackVolume(id: number, trackIndex: number, volume: number): void;
+
+    //% shim=music::_sequencerSetDrumTrackVolume
+    declare function _sequencerSetDrumTrackVolume(id: number, trackIndex: number, drumIndex: number, volume: number): void;
+
+    //% shim=music::_sequencerDispose
+    declare function _sequencerDispose(id: number): void;
 }

package/libs/mixer/sim/music.ts

@@ -9,7 +9,109 @@ namespace pxsim.music {
 
     export function stopPlaying() {
         AudioContextManager.muteAllChannels()
+
+        if (sequencers) {
+            for (const seq of sequencers) {
+                seq.sequencer.stop();
+                seq.sequencer.dispose();
+            }
+        }
     }
 
     export function forceOutput(mode: number) { }
+
+    export const SEQUENCER_STOP_MESSAGE = 3243;
+    export const SEQUENCER_TICK_MESSAGE = 3244;
+    export const SEQUENCER_STATE_CHANGE_MESSAGE = 3245;
+    export const SEQUENCER_LOOPED_MESSAGE = 3246;
+
+    interface SequencerWithId {
+        id: number;
+        sequencer: Sequencer;
+    }
+
+    let sequencers: SequencerWithId[];
+    let nextSequencerId = 0;
+
+    export async function _createSequencer(): Promise<number> {
+        if (!sequencers) {
+            pxsim.AudioContextManager.onStopAll(() => {
+                for (const seq of sequencers) {
+                    seq.sequencer.stop();
+                    seq.sequencer.dispose();
+                }
+                sequencers = [];
+            })
+
+            sequencers = [];
+        }
+        const res = {
+            id: nextSequencerId++,
+            sequencer: new Sequencer()
+        };
+
+        sequencers.push(res)
+
+        await res.sequencer.initAsync();
+        res.sequencer.addEventListener("stop", () => {
+            board().bus.queue(SEQUENCER_STOP_MESSAGE, this.id);
+        });
+        res.sequencer.addEventListener("state-change", () => {
+            board().bus.queue(SEQUENCER_STATE_CHANGE_MESSAGE, this.id);
+        });
+        res.sequencer.addEventListener("looped", () => {
+            board().bus.queue(SEQUENCER_LOOPED_MESSAGE, this.id);
+        });
+        res.sequencer.addEventListener("tick", () => {
+            board().bus.queue(SEQUENCER_TICK_MESSAGE, this.id);
+        });
+
+
+        return res.id;
+    }
+
+    export function _sequencerState(id: number): string {
+        return lookupSequencer(id)?.state();
+    }
+
+    export function _sequencerCurrentTick(id: number): number {
+        return lookupSequencer(id)?.currentTick();
+    }
+
+    export function _sequencerPlaySong(id: number, song: RefBuffer, loop: boolean): void {
+        const decoded = decodeSong(song.data);
+        lookupSequencer(id)?.start(decoded, loop);
+    }
+
+    export function _sequencerStop(id: number): void {
+        lookupSequencer(id)?.stop();
+    }
+
+    export function _sequencerSetVolume(id: number, volume: number): void {
+        lookupSequencer(id)?.setVolume(volume);
+    }
+
+    export function _sequencerSetVolumeForAll(volume: number): void {
+        for (const seq of sequencers) {
+            seq.sequencer.setVolume(volume);
+        }
+    }
+
+    export function _sequencerSetTrackVolume(id: number, trackIndex: number, volume: number): void {
+        lookupSequencer(id)?.setTrackVolume(trackIndex, volume);
+    }
+
+    export function _sequencerSetDrumTrackVolume(id: number, trackIndex: number, drumIndex: number, volume: number): void {
+        lookupSequencer(id)?.setDrumTrackVolume(trackIndex, drumIndex, volume);
+    }
+
+    export function _sequencerDispose(id: number) {
+        lookupSequencer(id)?.dispose();
+        sequencers = sequencers.filter(s => s.id !== id);
+    }
+
+    function lookupSequencer(id: number) {
+        for (const seq of sequencers) if (seq.id === id) return seq.sequencer;
+        return undefined;
+    }
 }