0.2.16

.travis.yml

@@ -3,6 +3,7 @@ node_js:
   - "5.7.0"
 script:
   - "node node_modules/kindscript/built/kind.js travis"  
+  - "(cd libs/lang-test0; node ../../node_modules/kindscript/built/kind.js run)"
   - "node node_modules/kindscript/built/kind.js uploaddoc"
 sudo: false
 notifications:

libs/hello/kind.json

@@ -6,6 +6,7 @@
     ],
     "public": true,
     "dependencies": {
-        "microbit": "file:../microbit"
+        "microbit": "file:../microbit",
+        "microbit-radio": "file:../microbit-radio"
     }
 }

libs/lang-test0/kind.json

@@ -0,0 +1,12 @@
+{
+    "name": "lang-test0",
+    "description": "Test for the TypeScript -> HEX compiler",
+    "installedVersion": "file:.",
+    "files": [
+        "lang-test0.ts"
+    ],
+    "public": true,
+    "dependencies": {
+        "microbit": "file:../microbit"
+    }
+}

libs/lang-test0/lang-test0.ts

@@ -0,0 +1,774 @@
+//
+// Note that this is supposed to run from command line.
+// Do not use anything besides basic.pause, control.inBackground, console.log
+//
+
+//% shim=ksrt::panic
+function panic(code2: number): void { }
+
+function msg(s: string): void {
+    //console.log(s)
+    //basic.pause(50);
+}
+
+function assert(cond: boolean, msg_: string) {
+    if (!cond) {
+        console.log("ASSERT: " + msg_);
+        panic(45);
+    }
+}
+
+//
+// start tests
+//
+
+var glb1: number;
+var s2: string;
+var x: number;
+var action: Action;
+var tot: string;
+var lazyAcc: number;
+var sum: number;
+
+var xyz = 12;
+
+console.log("Starting...")
+
+//lib.print_17(3);
+basic.showNumber(0);
+//assert(lib3.getX() == 17 * 3, "");
+
+testNums();
+testStrings();
+testNumCollection();
+testStringCollection();
+testStringOps();
+testReccoll();
+inBg();
+testAction(1);
+testAction(7);
+testIter();
+testActionSave();
+testLazyOps();
+testRefLocals();
+testByRefParams();
+testFunDecl();
+testDefaultArgs();
+testMemoryFree();
+testMemoryFreeHOF();
+postPreFix()
+eqOp()
+testEnums()
+testBuffer()
+
+// test some top-level code
+let xsum = 0;
+for (let i = 0; i < 11; ++i) {
+    xsum = xsum + i;
+}
+assert(xsum == 55, "mainfor")
+
+control.inBackground(() => {
+    xsum = xsum + 10;
+})
+
+basic.pause(20)
+assert(xsum == 65, "mainforBg")
+
+assert(xyz == 12, "init")
+
+function incrXyz() {
+    xyz++;
+    return 0;
+}
+var unusedInit = incrXyz();
+
+assert(xyz == 13, "init2")
+
+
+testClass()
+
+basic.showNumber(1)
+
+
+console.log("ALL TESTS OK")
+
+
+function defaultArgs(x: number, y = 3, z = 7) {
+    return x + y + z;
+}
+
+function testDefaultArgs() {
+    msg("testDefaultArgs");
+    assert(defaultArgs(1) == 11, "defl0")
+    assert(defaultArgs(1, 4) == 12, "defl1")
+    assert(defaultArgs(1, 4, 8) == 13, "defl2")
+
+    assert(optargs(1) == 1, "opt0");
+    assert(optargs(1, 2) == 3, "opt1");
+    assert(optargs(1, 2, 3) == 3, "opt2");
+
+    assert(optstring(3) == 6, "os0")
+    assert(optstring(3, "7") == 10, "os1")
+    assert(optstring2(3) == 6, "os0")
+    assert(optstring2(3, "7") == 10, "os1")
+}
+
+function optargs(x: number, y ?: number, z ?: number) {
+    return x + y;
+}
+
+function optstring(x: number, s ?: string) {
+    if (s != null) {
+        return parseInt(s) + x;
+    }
+    return x * 2;
+}
+
+function optstring2(x: number, s: string = null) {
+    if (s != null) {
+        return parseInt(s) + x;
+    }
+    return x * 2;
+}
+
+function testNums(): void {
+    let x = 40 + 2;
+    assert(x == 42, "add");
+    x = 40 / 2;
+    assert(x == 20, "div");
+    let r = fib(15);
+    msg("FIB" + r);
+    assert(r == 987, "fib");
+    let x3 = doStuff(x, 2);
+    assert(x3 == 10, "call order");
+    glb1 = 5;
+    incrBy_2();
+    assert(glb1 == 7, "glb1");
+    incrBy_2();
+    assert(glb1 == 9, "glb2");
+    assert(Math.abs(-42) == 42, "abs");
+    assert(Math.abs(42) == 42, "abs");
+    assert(Math.sign(42) == 1, "abs");
+    testIf();
+
+    assert((3 & 6) == 2, "&")
+    assert((3 | 6) == 7, "|")
+    assert((3 ^ 6) == 5, "^")
+    assert((-10 >> 2) == -3, ">>")
+    assert((-10 >>> 20) == 4095, ">>>")
+    assert((-10 << 2) == -40, "<<")
+    assert((10 << 2) == 40, "<<+")
+    assert((10 >> 2) == 2, ">>+")
+    assert((10 >>> 2) == 2, ">>>+")
+    assert(1000000 * 1000000 == -727379968, "*")
+    assert(100000001 * 100000001 == 2074919425, "*2")
+
+    assert(105 % 100 == 5, "perc")
+}
+
+
+
+function fib(p: number): number {
+    if (p <= 2) {
+        return p;
+    }
+    let p2 = p - 1;
+    return fib(p2) + fib(p - 2);
+}
+
+function doStuff(x: number, x2: number): number {
+    let x3 = x / x2;
+    return x3;
+}
+
+
+function testIf(): void {
+    let b = false;
+    if (!b) {
+        glb1 = 7;
+    } else {
+        assert(false, "b0");
+    }
+    assert(glb1 == 7, "glb3");
+    if (b) {
+        assert(false, "b1");
+    } else {
+        glb1 = 8;
+    }
+    assert(glb1 == 8, "glb3");
+}
+
+
+function incrBy_2(): void {
+    glb1 = glb1 + 2;
+}
+
+function testStrings(): void {
+    assert((42).toString() == "42", "42");
+
+    let s = "live";
+    assert(s == "live", "hello eq");
+    s = s + "4OK";
+    s2 = s;
+    assert(s.charCodeAt(4) == 52, "hello eq2");
+    assert(s.charAt(4) == "4", "hello eq2X");
+    assert(s[4] == "4", "hello eq2X");
+    assert(s.length == 7, "len7");
+    s = "";
+    for (let i = 0; i < 10; i++) {
+        s = s + i;
+    }
+    assert(s == "0123456789", "for");
+    let x = 10;
+    s = "";
+    while (x >= 0) {
+        s = s + x;
+        x = x - 1;
+    }
+    assert(s == "109876543210", "while");
+    msg(s);
+    msg(s2);
+
+    s2 = "";
+    // don't leak ref
+
+    x = 21
+    s = "foo"
+    s = `a${ x * 2 }X${ s }X${ s }Z`
+    assert(s == "a42XfooXfoo" + "Z", "`")
+
+    assert("X" + true == "Xt" + "rue", "boolStr")
+}
+
+
+function testNumCollection(): void {
+    let collXYZ: number[] =[];
+    assert(collXYZ.length == 0, "");
+    collXYZ.push(42);
+    assert(collXYZ.length == 1, "");
+    collXYZ.push(22);
+    assert(collXYZ[1] == 22, "");
+    collXYZ.splice(0, 1);
+    assert(collXYZ[0] == 22, "");
+    collXYZ.removeElement(22);
+    assert(collXYZ.length == 0, "");
+    for (let i = 0; i < 100; i++) {
+        collXYZ.push(i);
+    }
+    assert(collXYZ.length == 100, "");
+
+    collXYZ =[1, 2, 3];
+    assert(collXYZ.length == 3, "cons");
+    assert(collXYZ[0] == 1, "cons0");
+    assert(collXYZ[1] == 2, "cons1");
+    assert(collXYZ[2] == 3, "cons2");
+}
+
+function testStringCollection(): void {
+    let coll = (< string[] >[]);
+    coll.push("foobar");
+    coll.push((12).toString());
+    coll.push(coll[0] + "xx");
+    assert(coll.indexOf("12") == 1, "idx");
+    coll =[
+        "a" + "b",
+        coll[2],
+    ]
+    assert(coll[0] == "ab", "")
+    assert(coll[1] == "foob" + "arxx", "")
+    assert(coll.length == 2, "")
+}
+
+function testStringOps(): void {
+    assert("foo".concat("bar") == "foobar", "concat");
+    assert("xAb".charCodeAt(1) == 65, "code at");
+    assert("B".charCodeAt(0) == 66, "tcc");
+    assert(parseInt("-123") == -123, "tonum");
+    assert("fo"[1] == "o", "at");
+    assert("fo".length == 2, "count");
+    assert("fo".charCodeAt(17) == 0, "ct oor");
+}
+
+class Testrec {
+    str: string;
+    num: number;
+    bool: boolean;
+    str2: string;
+}
+
+function recordId(x: Testrec) {
+    lazyAcc++
+    return x
+}
+
+function postPreFix() {
+    msg("postPref")
+    let x = new Testrec()
+    lazyAcc = 0
+    recordId(x).num = 12
+    assert(x.num == 12 && lazyAcc == 1, "X0")
+    let y = recordId(x).num++
+    assert(x.num == 13 && lazyAcc == 2, "X1")
+    assert(y == 12, "X2")
+    y = ++recordId(x).num
+    assert(y == 14 && x.num == 14 && lazyAcc == 3, "X2")
+
+    recordId(x).num >>= 1
+    assert(x.num == 7, "X3")
+    assert(lazyAcc == 4, "X4")
+}
+
+function eqOp() {
+    msg("eqOp")
+    let x = 12
+    assert((x += 10) == 22, "Y0")
+    assert(x == 22, "Y1")
+    x /= 2
+    assert(x == 11, "Y2")
+
+    let s = ("fo" + 1)
+    let t = ("ba" + 2)
+    s += t
+    assert(s == "fo1b" + "a2", "fb")
+}
+
+function testRec0(): Testrec {
+    let testrec = new Testrec();
+    testrec.str2 = "Hello" + " world";
+    testrec.str = testrec.str2;
+    testrec.num = 42;
+    assert(testrec.str == "Hello world", "recstr");
+    assert(testrec.num == 42, "recnum");
+    msg(testrec.str2);
+    let testrec2 = < Testrec > null;
+    assert(testrec2 == null, "isinv");
+    assert(testrec == testrec, "eq");
+    assert(testrec != null, "non inv");
+    return testrec;
+}
+
+function testReccoll(): void {
+    let coll: Testrec[] =[];
+    let item = testRec0();
+    msg("in reccoll");
+    coll.push(item);
+}
+
+function inBg() {
+    let k = 7
+    let q = 14
+    let rec = new Testrec();
+    glb1 = 0
+    control.inBackground(() => {
+        glb1 = glb1 + 10 + (q - k)
+        rec.str = "foo"
+    })
+    control.inBackground(() => {
+        glb1 = glb1 + 1
+    })
+    basic.pause(50)
+    assert(glb1 == 18, "inbg0")
+    assert(rec.str == "foo", "inbg1")
+}
+
+function runTwice(fn: Action): void {
+    msg("r2 start");
+    fn();
+    fn();
+    msg("r2 stop");
+}
+
+function iter(max: number, fn: (v: number) => void) {
+    for (var i = 0; i < max; ++i) {
+        fn(i);
+    }
+}
+
+function testIter() {
+    x = 0
+    iter(10, v => {
+        x = x + (v + 1)
+    })
+    assert(x == 55, "55")
+}
+
+function testAction(p: number): void {
+    let s = "hello" + "1";
+    let coll =[] as number[];
+    let p2 = p * 2;
+    x = 42;
+    runTwice(() => {
+        x = x + p + p2;
+        coll.push(x);
+        msg(s + x);
+    });
+    assert(x == 42 + p * 6, "run2");
+    assert(coll.length == 2, "run2");
+}
+
+function add7() {
+    sum = sum + 7;
+}
+
+function testFunDecl() {
+    msg("testFunDecl");
+    let x = 12;
+    sum = 0;
+    function addX() {
+        sum = sum + x;
+    }
+    function add10() {
+        sum = sum + 10;
+    }
+    runTwice(addX)
+    assert(sum == 24, "cap")
+    msg("testAdd10");
+    runTwice(add10);
+    msg("end-testAdd10");
+    assert(sum == 44, "nocap");
+    runTwice(add7);
+    assert(sum == 44 + 14, "glb")
+    addX();
+    add10();
+    assert(sum == 44 + 14 + x + 10, "direct");
+}
+
+function saveAction(fn: Action): void {
+    action = fn;
+}
+
+function saveGlobalAction(): void {
+    let s = "foo" + "42";
+    tot = "";
+    saveAction(() => {
+        tot = tot + s;
+    });
+}
+
+function testActionSave(): void {
+    saveGlobalAction();
+    runTwice(action);
+    msg(tot);
+    assert(tot == "foo42foo42", "");
+    tot = "";
+    action = null;
+}
+
+function testLazyOps(): void {
+    lazyAcc = 0;
+    if (incrLazyAcc(10, false) && incrLazyAcc(1, true)) {
+        assert(false, "");
+    } else {
+        assert(lazyAcc == 10, "lazy1");
+    }
+    assert(lazyAcc == 10, "lazy2");
+    if (incrLazyAcc(100, true) && incrLazyAcc(1, false)) {
+        assert(false, "");
+    } else {
+        assert(lazyAcc == 111, "lazy4");
+    }
+    lazyAcc = 0;
+    if (incrLazyAcc(100, true) && incrLazyAcc(8, true)) {
+        assert(lazyAcc == 108, "lazy5");
+    } else {
+        assert(false, "");
+    }
+    lazyAcc = 0;
+    if (incrLazyAcc(10, true) || incrLazyAcc(1, true)) {
+        assert(lazyAcc == 10, "lazy1b");
+    } else {
+        assert(false, "");
+    }
+    assert(lazyAcc == 10, "lazy2xx");
+    if (incrLazyAcc(100, false) || incrLazyAcc(1, false)) {
+        assert(false, "");
+    } else {
+        assert(lazyAcc == 111, "lazy4x");
+    }
+    lazyAcc = 0;
+    if (incrLazyAcc(100, false) || incrLazyAcc(8, true)) {
+        assert(lazyAcc == 108, "lazy5");
+    } else {
+        assert(false, "");
+    }
+    lazyAcc = 0;
+    if (incrLazyAcc(10, true) && incrLazyAcc(1, true) && incrLazyAcc(100, false)) {
+        assert(false, "");
+    } else {
+        assert(lazyAcc == 111, "lazy10");
+    }
+    lazyAcc = 0;
+    if (incrLazyAcc(10, true) && incrLazyAcc(1, true) || incrLazyAcc(100, false)) {
+        assert(lazyAcc == 11, "lazy101");
+    } else {
+        assert(false, "");
+    }
+
+    lazyAcc = 0;
+    assert((true ? incrLazyNum(1, 42): incrLazyNum(10, 36)) == 42, "?:")
+    assert(lazyAcc == 1, "?:0");
+    assert((false ? incrLazyNum(1, 42): incrLazyNum(10, 36)) == 36, "?:1")
+    assert(lazyAcc == 11, "?:2");
+}
+
+function incrLazyAcc(delta: number, res: boolean): boolean {
+    lazyAcc = lazyAcc + delta;
+    return res;
+}
+
+function incrLazyNum(delta: number, res: number) {
+    lazyAcc = lazyAcc + delta;
+    return res;
+}
+
+
+function testRefLocals(): void {
+    msg("start test ref locals");
+    let s = "";
+    // For 4 or more it runs out of memory
+    for (let i = 0; i < 3; i++) {
+        msg(i + "");
+        let copy = i;
+        control.inBackground(() => {
+            basic.pause(10 * i);
+            copy = copy + 10;
+        });
+        control.inBackground(() => {
+            basic.pause(20 * i);
+            s = s + copy;
+        });
+    }
+    basic.pause(200);
+    assert(s == "101112", "reflocals");
+}
+
+function byRefParam_0(p: number): void {
+    control.inBackground(() => {
+        basic.pause(1);
+        sum = sum + p;
+    });
+    p = p + 1;
+}
+
+function byRefParam_2(pxx: number): void {
+    pxx = pxx + 1;
+    control.inBackground(() => {
+        basic.pause(1);
+        sum = sum + pxx;
+    });
+}
+
+function testByRefParams(): void {
+    msg("testByRefParams");
+    refparamWrite("a" + "b");
+    refparamWrite2(new Testrec());
+    refparamWrite3(new Testrec());
+    sum = 0;
+    let x = 1;
+    control.inBackground(() => {
+        basic.pause(1);
+        sum = sum + x;
+    });
+    x = 2;
+    byRefParam_0(4);
+    byRefParam_2(10);
+    basic.pause(30);
+    assert(sum == 18, "by ref");
+}
+
+function refparamWrite(s: string): void {
+    s = s + "c";
+    assert(s == "abc", "abc");
+}
+
+function refparamWrite2(testrec: Testrec): void {
+    testrec = new Testrec();
+    assert(testrec.bool == false, "");
+}
+
+function refparamWrite3(testrecX: Testrec): void {
+    control.inBackground(() => {
+        basic.pause(1);
+        assert(testrecX.str == "foo", "ff");
+        testrecX.str = testrecX.str + "x";
+    });
+    testrecX = new Testrec();
+    testrecX.str = "foo";
+    basic.pause(30);
+    assert(testrecX.str == "foox", "ff2");
+}
+
+function testMemoryFree(): void {
+    msg("testMemoryFree");
+    for (let i = 0; i < 1000; i++) {
+        allocImage();
+    }
+}
+
+function runOnce(fn: Action): void {
+    fn();
+}
+
+function createObj() {
+    return new Testrec();
+}
+
+function testMemoryFreeHOF(): void {
+    msg("testMemoryFreeHOF");
+    for (let i = 0; i < 1000; i++) {
+        runOnce(() => {
+            let tmp = createObj();
+        });
+    }
+}
+
+function allocImage(): void {
+    let tmp = createObj();
+}
+
+class Foo {
+    pin: number;
+    buf: number[];
+
+    constructor(k: number, l: number) {
+        this.pin = k - l
+    }
+
+    setPin(p: number) {
+        this.pin = p
+    }
+
+    getPin() {
+        return this.pin
+    }
+
+    init() {
+        this.buf =[1, 2]
+    }
+}
+
+function testClass() {
+    let f = new Foo(272, 100);
+    assert(f.getPin() == 172, "ctor")
+    f.setPin(42)
+    assert(f.getPin() == 42, "getpin")
+}
+
+enum En {
+    A,
+    B,
+    C,
+    D = 4200,
+    E,
+}
+
+enum En2 {
+    D0 = En.D,
+    D1,
+    D2 = 1,
+}
+
+
+function testEnums() {
+    msg("enums")
+
+    let k = En.C as number
+    assert(k == 2, "e0")
+    k = En.D as number
+    assert(k == 4200, "e1")
+    k = En.E as number
+    assert(k == 4201, "e43")
+
+    k = En2.D0 as number
+    assert(k == 4200, "eX0")
+    k = En2.D1 as number
+    assert(k == 4201, "eX1")
+
+    msg("enums0")
+    assert(switchA(En.A) == 7, "s1")
+    assert(switchA(En.B) == 7, "s2")
+    assert(switchA(En.C) == 12, "s3")
+    assert(switchA(En.D) == 13, "s4")
+    assert(switchA(En.E) == 12, "s5")
+    assert(switchA(-3 as En) == 12, "s6")
+
+    msg("enums1")
+    assert(switchB(En.A) == 7, "x1")
+    assert(switchB(En.B) == 7, "x2")
+    assert(switchB(En.C) == 17, "x3")
+    assert(switchB(En.D) == 13, "x4")
+    assert(switchB(En.E) == 14, "x5")
+}
+
+
+function switchA(e: En) {
+    let r = 12;
+    switch (e) {
+        case En.A:
+        case En.B: return 7;
+        case En.D: r = 13; break;
+    }
+    return r
+}
+
+function switchB(e: En) {
+    let r = 33;
+    switch (e) {
+        case En.A:
+        case En.B: return 7;
+        case En.D: r = 13; break;
+        case En.E: r = 14; break;
+        default: return 17;
+    }
+    return r;
+}
+
+function bufferIs(b:Buffer, a:number[]) {
+    assert(b.length == a.length, "bis-len")
+    for (let i = 0; i < a.length; ++i) {
+        if (a[i] != b[i]) {
+            assert(false, `bufferIs: buf[${i}]:${b[i]} != ${a[i]}`)
+        }
+    }
+}
+
+function testBuffer() {
+    let b = pins.createBuffer(3);
+    assert(b[0] == 0, "buf0");
+    assert(b[1] == 0, "buf0");
+    assert(b[2] == 0, "buf0");
+    assert(b[-100000] == 0, "bufM");
+    assert(b[100000] == 0, "bufM");
+
+    b[0] = 42;
+    bufferIs(b, [42, 0, 0]);
+    b[2] = 41;
+    bufferIs(b, [42, 0, 41]);
+
+    b.rotate(1)
+    bufferIs(b, [0, 41, 42]);
+    b.rotate(-2)
+    bufferIs(b, [41, 42, 0]);
+    b.shift(1)
+    bufferIs(b, [42, 0, 0]);
+    b.rotate(9)
+    bufferIs(b, [42, 0, 0]);
+    b.rotate(-9)
+    bufferIs(b, [42, 0, 0]);
+
+    b.fill(4);
+    bufferIs(b, [4, 4, 4]);
+
+    b.fill(12, 1, 1);
+    bufferIs(b, [4, 12, 4]);
+
+    b.fill(13, 1, -1);
+    bufferIs(b, [4, 13, 13]);
+
+    b.fill(100, -1, -1);
+    bufferIs(b, [4, 13, 13]);
+
+    b.shift(-1)
+    bufferIs(b, [0, 4, 13]);
+}

libs/microbit-devices/devices.cpp

@@ -0,0 +1,216 @@
+#include "kindscript.h"
+#include "MESEvents.h"
+
+using namespace kindscript;
+
+enum class MesCameraEvent {
+    //% block="take photo"
+    TakePhoto = MES_CAMERA_EVT_TAKE_PHOTO,
+    //% block="start video capture"
+    StartVideoCapture = MES_CAMERA_EVT_START_VIDEO_CAPTURE,
+    //% block="stop video capture"
+    StopVideoCapture = MES_CAMERA_EVT_STOP_VIDEO_CAPTURE,
+    //% block="toggle front-rear"
+    ToggleFrontRear = MES_CAMERA_EVT_TOGGLE_FRONT_REAR,
+    //% block="launch photo mode"
+    LaunchPhotoMode = MES_CAMERA_EVT_LAUNCH_PHOTO_MODE,
+    //% block="launch video mode"
+    LaunchVideoMode = MES_CAMERA_EVT_LAUNCH_VIDEO_MODE,
+    //% block="stop photo mode"
+    StopPhotoMode = MES_CAMERA_EVT_STOP_PHOTO_MODE,
+    //% block="stop video mode"
+    StopVideoMode = MES_CAMERA_EVT_STOP_VIDEO_MODE,
+};
+
+enum class MesAlertEvent {
+    //% block="display toast"
+    DisplayToast = MES_ALERT_EVT_DISPLAY_TOAST,
+    //% block="vibrate"
+    Vibrate = MES_ALERT_EVT_VIBRATE,
+    //% block="play sound"
+    PlaySound = MES_ALERT_EVT_PLAY_SOUND,
+    //% block="play ring tone"
+    PlayRingtone = MES_ALERT_EVT_PLAY_RINGTONE,
+    //% block="find my phone"
+    FindMyPhone = MES_ALERT_EVT_FIND_MY_PHONE,
+    //% block="ring alarm"
+    RingAlarm = MES_ALERT_EVT_ALARM1,
+    //% block="ring alarm 2"
+    RingAlarm2 = MES_ALERT_EVT_ALARM2,
+    //% block="ring alarm 3"
+    RingAlarm3 = MES_ALERT_EVT_ALARM3,
+    //% block="ring alarm 4"
+    RingAlarm4 = MES_ALERT_EVT_ALARM4,
+    //% block="ring alarm 5"
+    RingAlarm5 = MES_ALERT_EVT_ALARM5,
+    //% block="ring alarm 6"
+    RingAlarm6 = MES_ALERT_EVT_ALARM6,
+};
+
+enum class MesDeviceInfo {
+    //% block="incoming call"
+    IncomingCall = MES_DEVICE_INCOMING_CALL,
+    //% block="incoming message"
+    IncomingMessage = MES_DEVICE_INCOMING_MESSAGE,
+    //% block="orientation landscape"
+    OrientationLandscape = MES_DEVICE_ORIENTATION_LANDSCAPE,
+    //% block="orientation portrait"
+    OrientationPortrait = MES_DEVICE_ORIENTATION_PORTRAIT,
+    //% block="shaken"
+    Shaken = MES_DEVICE_GESTURE_DEVICE_SHAKEN,
+    //% block="display off"
+    DisplayOff = MES_DEVICE_DISPLAY_OFF,
+    //% block="display on"
+    DisplayOn = MES_DEVICE_DISPLAY_ON,
+};
+
+enum class MesRemoteControlEvent {
+    //% block="play"
+    play = MES_REMOTE_CONTROL_EVT_PLAY,
+    //% block="pause"
+    pause = MES_REMOTE_CONTROL_EVT_PAUSE,
+    //% block="stop"
+    stop = MES_REMOTE_CONTROL_EVT_STOP,
+    //% block="next track"
+    nextTrack = MES_REMOTE_CONTROL_EVT_NEXTTRACK,
+    //% block="previous track"
+    previousTrack = MES_REMOTE_CONTROL_EVT_PREVTRACK,
+    //% block="forward"
+    forward = MES_REMOTE_CONTROL_EVT_FORWARD,
+    //% block="rewind"
+    rewind = MES_REMOTE_CONTROL_EVT_REWIND,
+    //% block="volume up"
+    volumeUp = MES_REMOTE_CONTROL_EVT_VOLUMEUP,
+    //% block="volume down"
+    volumeDown = MES_REMOTE_CONTROL_EVT_VOLUMEDOWN,
+};
+
+enum class MesDpadButtonInfo {
+    //% block="A down"
+    ADown = MES_DPAD_BUTTON_A_DOWN,
+    //% block="A up"
+    AUp = MES_DPAD_BUTTON_A_UP,
+    //% block="B down"
+    BDown = MES_DPAD_BUTTON_B_DOWN,
+    //% block="B up"
+    BUp = MES_DPAD_BUTTON_B_UP,
+    //% block="C down"
+    CDown = MES_DPAD_BUTTON_C_DOWN,
+    //% block="C up"
+    CUp = MES_DPAD_BUTTON_C_UP,
+    //% block="D down"
+    DDown = MES_DPAD_BUTTON_D_DOWN,
+    //% block="D up"
+    DUp = MES_DPAD_BUTTON_D_UP,
+    //% block="1 down"
+    _1Down = MES_DPAD_BUTTON_1_UP,
+    //% block="1 up"
+    _1Up = MES_DPAD_BUTTON_1_DOWN,
+    //% block="2 down"
+    _2Down = MES_DPAD_BUTTON_2_DOWN,
+    //% block="2 up"
+    _2Up = MES_DPAD_BUTTON_2_UP,
+    //% block="3 down"
+    _3Down = MES_DPAD_BUTTON_3_DOWN,
+    //% block="3 up"
+    _3Up = MES_DPAD_BUTTON_3_UP,
+    //% block="4 down"
+    _4Down = MES_DPAD_BUTTON_4_DOWN,
+    //% block="4 up"
+    _4Up = MES_DPAD_BUTTON_4_UP,
+};
+
+
+//% color=156 weight=80
+namespace devices {
+    static void genEvent(int id, int event) {
+      MicroBitEvent e(id, event);
+    }
+
+    /**
+     * Sends a ``camera`` command to the parent device.
+     * @param event TODO
+     */
+    //% weight=30 help=devices/tell-camera-to
+    //% blockId=devices_camera icon="\uf030" block="tell camera to|%property" blockGap=8
+    void tellCameraTo(MesCameraEvent event) { 
+        genEvent(MES_CAMERA_ID, (int)event);
+    }
+
+    /**
+     * Sends a ``remote control`` command to the parent device.
+     * @param event TODO
+     */
+    //% weight=29 help=devices/tell-remote-control-to
+    //% blockId=devices_remote_control block="tell remote control to|%property" blockGap=14 icon="\uf144"
+    void tellRemoteControlTo(MesRemoteControlEvent event) { 
+        genEvent(MES_REMOTE_CONTROL_ID, (int)event);
+    }
+
+    /**
+     * Sends an ``alert`` command to the parent device.
+     * @param event TODO
+     */
+    //% weight=27 help=devices/raise-alert-to
+    //% blockId=devices_alert block="raise alert to|%property" icon="\uf0f3"
+    void raiseAlertTo(MesAlertEvent event) { 
+        genEvent(MES_ALERTS_ID, (int)event);
+    }
+
+    /**
+     * Registers code to run when the device notifies about a particular event.
+     * @param event TODO
+     * @param body TODO
+     */
+    //% help=devices/on-notified weight=26
+    //% blockId=devices_device_info_event block="on notified" icon="\uf10a"
+    void onNotified(MesDeviceInfo event, Action body) {
+        registerWithDal(MES_DEVICE_INFO_ID, (int)event, body);
+    }
+
+    /**
+     * Register code to run when the micro:bit receives a command from the paired gamepad.
+     * @param name TODO
+     * @param body TODO
+     */
+    //% help=devices/on-gamepad-button weight=40
+    //% weight=25
+    //% blockId=devices_gamepad_event block="on gamepad button|%NAME" icon="\uf11b"
+    void onGamepadButton(MesDpadButtonInfo name, Action body) {
+        registerWithDal(MES_DPAD_CONTROLLER_ID, (int)name, body);
+    }
+
+    static int _signalStrength = -1;
+    static void signalStrengthHandler(MicroBitEvent ev) { 
+        // keep in sync with MESEvents.h
+        _signalStrength = ev.value - 1; 
+    }
+    static void initSignalStrength() {
+        if (_signalStrength < 0) {
+            _signalStrength = 0;
+            uBit.MessageBus.listen(MES_SIGNAL_STRENGTH_ID, MICROBIT_EVT_ANY, signalStrengthHandler);
+        }        
+    }
+    
+    /**
+     * Returns the last signal strength reported by the paired device.
+     */
+    //% help=devices/signal-strength weight=24
+    //% blockId=devices_signal_strength block="signal strength" blockGap=14 icon="\uf012" blockGap=14
+    int signalStrength() {
+        initSignalStrength();
+        return _signalStrength;
+    }
+
+    /**
+     * Registers code to run when the device notifies about a change of signal strength.
+     * @param body TODO
+     */
+    //% weight=23 help=devices/on-signal-strength-changed
+    //% blockId=devices_signal_strength_changed_event block="on signal strength changed" icon="\uf012"
+    void onSignalStrengthChanged(Action body) {
+        initSignalStrength();    
+        registerWithDal(MES_SIGNAL_STRENGTH_ID, MICROBIT_EVT_ANY, body);
+    }
+}
+

libs/microbit-devices/devices.ts

@@ -1,181 +0,0 @@
-enum MesCameraEvent {
-    //% enumval=MES_CAMERA_EVT_TAKE_PHOTO block="take photo"
-    TakePhoto,
-    //% enumval=MES_CAMERA_EVT_START_VIDEO_CAPTURE block="start video capture"
-    StartVideoCapture,
-    //% enumval=MES_CAMERA_EVT_STOP_VIDEO_CAPTURE block="stop video capture"
-    StopVideoCapture,
-    //% enumval=MES_CAMERA_EVT_TOGGLE_FRONT_REAR block="toggle front-rear"
-    ToggleFrontRear,
-    //% enumval=MES_CAMERA_EVT_LAUNCH_PHOTO_MODE block="launch photo mode"
-    LaunchPhotoMode,
-    //% enumval=MES_CAMERA_EVT_LAUNCH_VIDEO_MODE block="launch video mode"
-    LaunchVideoMode,
-    //% enumval=MES_CAMERA_EVT_STOP_PHOTO_MODE block="stop photo mode"
-    StopPhotoMode,
-    //% enumval=MES_CAMERA_EVT_STOP_VIDEO_MODE block="stop video mode"
-    StopVideoMode,
-}
-
-enum MesAlertEvent {
-    //% enumval=MES_ALERT_EVT_DISPLAY_TOAST block="display toast"
-    DisplayToast,
-    //% enumval=MES_ALERT_EVT_VIBRATE block="vibrate"
-    Vibrate,
-    //% enumval=MES_ALERT_EVT_PLAY_SOUND block="play sound"
-    PlaySound,
-    //% enumval=MES_ALERT_EVT_PLAY_RINGTONE block="play ring tone"
-    PlayRingtone,
-    //% enumval=MES_ALERT_EVT_FIND_MY_PHONE block="find my phone"
-    FindMyPhone,
-    //% enumval=MES_ALERT_EVT_ALARM1 block="ring alarm"
-    RingAlarm,
-    //% enumval=MES_ALERT_EVT_ALARM2 block="ring alarm 2"
-    RingAlarm2,
-    //% enumval=MES_ALERT_EVT_ALARM3 block="ring alarm 3"
-    RingAlarm3,
-    //% enumval=MES_ALERT_EVT_ALARM4 block="ring alarm 4"
-    RingAlarm4,
-    //% enumval=MES_ALERT_EVT_ALARM5 block="ring alarm 5"
-    RingAlarm5,
-    //% enumval=MES_ALERT_EVT_ALARM6 block="ring alarm 6"
-    RingAlarm6,
-}
-
-enum MesDeviceInfo {
-    //% enumval=MES_DEVICE_INCOMING_CALL block="incoming call"
-    IncomingCall,
-    //% enumval=MES_DEVICE_INCOMING_MESSAGE block="incoming message"
-    IncomingMessage,
-    //% enumval=MES_DEVICE_ORIENTATION_LANDSCAPE block="orientation landscape"
-    OrientationLandscape,
-    //% enumval=MES_DEVICE_ORIENTATION_PORTRAIT block="orientation portrait"
-    OrientationPortrait,
-    //% enumval=MES_DEVICE_GESTURE_DEVICE_SHAKEN block="shaken"
-    Shaken,
-    //% enumval=MES_DEVICE_DISPLAY_OFF block="display off"
-    DisplayOff,
-    //% enumval=MES_DEVICE_DISPLAY_ON block="display on"
-    DisplayOn,
-}
-
-enum MesRemoteControlEvent {
-    //% enumval=MES_REMOTE_CONTROL_EVT_PLAY block="play"
-    play,
-    //% enumval=MES_REMOTE_CONTROL_EVT_PAUSE block="pause"
-    pause,
-    //% enumval=MES_REMOTE_CONTROL_EVT_STOP block="stop"
-    stop,
-    //% enumval=MES_REMOTE_CONTROL_EVT_NEXTTRACK block="next track"
-    nextTrack,
-    //% enumval=MES_REMOTE_CONTROL_EVT_PREVTRACK block="previous track"
-    previousTrack,
-    //% enumval=MES_REMOTE_CONTROL_EVT_FORWARD block="forward"
-    forward,
-    //% enumval=MES_REMOTE_CONTROL_EVT_REWIND block="rewind"
-    rewind,
-    //% enumval=MES_REMOTE_CONTROL_EVT_VOLUMEUP block="volume up"
-    volumeUp,
-    //% enumval=MES_REMOTE_CONTROL_EVT_VOLUMEDOWN block="volume down"
-    volumeDown,
-}
-
-enum MesDpadButtonInfo {
-    //% enumval=MES_DPAD_BUTTON_A_DOWN block="A down"
-    ADown,
-    //% enumval=MES_DPAD_BUTTON_A_UP block="A up"
-    AUp,
-    //% enumval=MES_DPAD_BUTTON_B_DOWN block="B down"
-    BDown,
-    //% enumval=MES_DPAD_BUTTON_B_UP block="B up"
-    BUp,
-    //% enumval=MES_DPAD_BUTTON_C_DOWN block="C down"
-    CDown,
-    //% enumval=MES_DPAD_BUTTON_C_UP block="C up"
-    CUp,
-    //% enumval=MES_DPAD_BUTTON_D_DOWN block="D down"
-    DDown,
-    //% enumval=MES_DPAD_BUTTON_D_UP block="D up"
-    DUp,
-    //% enumval=MES_DPAD_BUTTON_1_UP block="1 down"
-    _1Down,
-    //% enumval=MES_DPAD_BUTTON_1_DOWN block="1 up"
-    _1Up,
-    //% enumval=MES_DPAD_BUTTON_2_DOWN block="2 down"
-    _2Down,
-    //% enumval=MES_DPAD_BUTTON_2_UP block="2 up"
-    _2Up,
-    //% enumval=MES_DPAD_BUTTON_3_DOWN block="3 down"
-    _3Down,
-    //% enumval=MES_DPAD_BUTTON_3_UP block="3 up"
-    _3Up,
-    //% enumval=MES_DPAD_BUTTON_4_DOWN block="4 down"
-    _4Down,
-    //% enumval=MES_DPAD_BUTTON_4_UP block="4 up"
-    _4Up,
-}
-
-//% color=156 weight=80
-namespace devices {
-    /**
-     * Sends a ``camera`` command to the parent device.
-     * @param event TODO
-     */
-    //% weight=30 help=devices/tell-camera-to shim=micro_bit::devices::camera
-    //% blockId=devices_camera icon="\uf030" block="tell camera to|%property" blockGap=8
-    export function tellCameraTo(event: MesCameraEvent): void { }
-
-    /**
-     * Sends a ``remote control`` command to the parent device.
-     * @param event TODO
-     */
-    //% weight=29 help=devices/tell-remote-control-to shim=micro_bit::devices::remote_control
-    //% blockId=devices_remote_control block="tell remote control to|%property" blockGap=14 icon="\uf144"
-    export function tellRemoteControlTo(event: MesRemoteControlEvent): void { }
-
-    /**
-     * Sends an ``alert`` command to the parent device.
-     * @param event TODO
-     */
-    //% weight=27 help=devices/raise-alert-to shim=micro_bit::devices::alert
-    //% blockId=devices_alert block="raise alert to|%property" icon="\uf0f3"
-    export function raiseAlertTo(event: MesAlertEvent): void { }
-
-    /**
-     * Registers code to run when the device notifies about a particular event.
-     * @param event TODO
-     * @param body TODO
-     */
-    //% shim=micro_bit::onDeviceInfo help=devices/on-notified
-    //% weight=26
-    //% blockId=devices_device_info_event block="on notified" icon="\uf10a"
-    export function onNotified(event: MesDeviceInfo, body: Action): void { }
-
-    /**
-     * Register code to run when the micro:bit receives a command from the paired gamepad.
-     * @param name TODO
-     * @param body TODO
-     */
-    //% help=devices/on-gamepad-button weight=40 shim=micro_bit::onGamepadButton
-    //% weight=25
-    //% blockId=devices_gamepad_event block="on gamepad button|%NAME" icon="\uf11b"
-    export function onGamepadButton(name: MesDpadButtonInfo, body: Action): void { }
-
-    /**
-     * Returns the last signal strength reported by the paired device.
-     */
-    //% help=devices/signal-strength weight=24 shim=micro_bit::signalStrength
-    //% blockId=devices_signal_strength block="signal strength" blockGap=14 icon="\uf012" blockGap=14
-    export function signalStrength(): number {
-        return 0;
-    }
-
-    /**
-     * Registers code to run when the device notifies about a change of signal strength.
-     * @param body TODO
-     */
-    //% shim=micro_bit::onSignalStrengthChanged weight=23 help=devices/on-signal-strength-changed
-    //% blockId=devices_signal_strength_changed_event block="on signal strength changed" icon="\uf012"
-    export function onSignalStrengthChanged(body: Action): void { }
-}
-

libs/microbit-devices/enums.d.ts

@@ -0,0 +1,127 @@
+// Auto-generated. Do not edit.
+
+
+    declare enum MesCameraEvent {
+    //% block="take photo"
+    TakePhoto = 3,  // MES_CAMERA_EVT_TAKE_PHOTO
+    //% block="start video capture"
+    StartVideoCapture = 4,  // MES_CAMERA_EVT_START_VIDEO_CAPTURE
+    //% block="stop video capture"
+    StopVideoCapture = 5,  // MES_CAMERA_EVT_STOP_VIDEO_CAPTURE
+    //% block="toggle front-rear"
+    ToggleFrontRear = 8,  // MES_CAMERA_EVT_TOGGLE_FRONT_REAR
+    //% block="launch photo mode"
+    LaunchPhotoMode = 1,  // MES_CAMERA_EVT_LAUNCH_PHOTO_MODE
+    //% block="launch video mode"
+    LaunchVideoMode = 2,  // MES_CAMERA_EVT_LAUNCH_VIDEO_MODE
+    //% block="stop photo mode"
+    StopPhotoMode = 6,  // MES_CAMERA_EVT_STOP_PHOTO_MODE
+    //% block="stop video mode"
+    StopVideoMode = 7,  // MES_CAMERA_EVT_STOP_VIDEO_MODE
+    }
+
+
+    declare enum MesAlertEvent {
+    //% block="display toast"
+    DisplayToast = 1,  // MES_ALERT_EVT_DISPLAY_TOAST
+    //% block="vibrate"
+    Vibrate = 2,  // MES_ALERT_EVT_VIBRATE
+    //% block="play sound"
+    PlaySound = 3,  // MES_ALERT_EVT_PLAY_SOUND
+    //% block="play ring tone"
+    PlayRingtone = 4,  // MES_ALERT_EVT_PLAY_RINGTONE
+    //% block="find my phone"
+    FindMyPhone = 5,  // MES_ALERT_EVT_FIND_MY_PHONE
+    //% block="ring alarm"
+    RingAlarm = 6,  // MES_ALERT_EVT_ALARM1
+    //% block="ring alarm 2"
+    RingAlarm2 = 7,  // MES_ALERT_EVT_ALARM2
+    //% block="ring alarm 3"
+    RingAlarm3 = 8,  // MES_ALERT_EVT_ALARM3
+    //% block="ring alarm 4"
+    RingAlarm4 = 9,  // MES_ALERT_EVT_ALARM4
+    //% block="ring alarm 5"
+    RingAlarm5 = 10,  // MES_ALERT_EVT_ALARM5
+    //% block="ring alarm 6"
+    RingAlarm6 = 11,  // MES_ALERT_EVT_ALARM6
+    }
+
+
+    declare enum MesDeviceInfo {
+    //% block="incoming call"
+    IncomingCall = 7,  // MES_DEVICE_INCOMING_CALL
+    //% block="incoming message"
+    IncomingMessage = 8,  // MES_DEVICE_INCOMING_MESSAGE
+    //% block="orientation landscape"
+    OrientationLandscape = 1,  // MES_DEVICE_ORIENTATION_LANDSCAPE
+    //% block="orientation portrait"
+    OrientationPortrait = 2,  // MES_DEVICE_ORIENTATION_PORTRAIT
+    //% block="shaken"
+    Shaken = 4,  // MES_DEVICE_GESTURE_DEVICE_SHAKEN
+    //% block="display off"
+    DisplayOff = 5,  // MES_DEVICE_DISPLAY_OFF
+    //% block="display on"
+    DisplayOn = 6,  // MES_DEVICE_DISPLAY_ON
+    }
+
+
+    declare enum MesRemoteControlEvent {
+    //% block="play"
+    play = 1,  // MES_REMOTE_CONTROL_EVT_PLAY
+    //% block="pause"
+    pause = 2,  // MES_REMOTE_CONTROL_EVT_PAUSE
+    //% block="stop"
+    stop = 3,  // MES_REMOTE_CONTROL_EVT_STOP
+    //% block="next track"
+    nextTrack = 4,  // MES_REMOTE_CONTROL_EVT_NEXTTRACK
+    //% block="previous track"
+    previousTrack = 5,  // MES_REMOTE_CONTROL_EVT_PREVTRACK
+    //% block="forward"
+    forward = 6,  // MES_REMOTE_CONTROL_EVT_FORWARD
+    //% block="rewind"
+    rewind = 7,  // MES_REMOTE_CONTROL_EVT_REWIND
+    //% block="volume up"
+    volumeUp = 8,  // MES_REMOTE_CONTROL_EVT_VOLUMEUP
+    //% block="volume down"
+    volumeDown = 9,  // MES_REMOTE_CONTROL_EVT_VOLUMEDOWN
+    }
+
+
+    declare enum MesDpadButtonInfo {
+    //% block="A down"
+    ADown = 1,  // MES_DPAD_BUTTON_A_DOWN
+    //% block="A up"
+    AUp = 2,  // MES_DPAD_BUTTON_A_UP
+    //% block="B down"
+    BDown = 3,  // MES_DPAD_BUTTON_B_DOWN
+    //% block="B up"
+    BUp = 4,  // MES_DPAD_BUTTON_B_UP
+    //% block="C down"
+    CDown = 5,  // MES_DPAD_BUTTON_C_DOWN
+    //% block="C up"
+    CUp = 6,  // MES_DPAD_BUTTON_C_UP
+    //% block="D down"
+    DDown = 7,  // MES_DPAD_BUTTON_D_DOWN
+    //% block="D up"
+    DUp = 8,  // MES_DPAD_BUTTON_D_UP
+    //% block="1 down"
+    _1Down = 10,  // MES_DPAD_BUTTON_1_UP
+    //% block="1 up"
+    _1Up = 9,  // MES_DPAD_BUTTON_1_DOWN
+    //% block="2 down"
+    _2Down = 11,  // MES_DPAD_BUTTON_2_DOWN
+    //% block="2 up"
+    _2Up = 12,  // MES_DPAD_BUTTON_2_UP
+    //% block="3 down"
+    _3Down = 13,  // MES_DPAD_BUTTON_3_DOWN
+    //% block="3 up"
+    _3Up = 14,  // MES_DPAD_BUTTON_3_UP
+    //% block="4 down"
+    _4Down = 15,  // MES_DPAD_BUTTON_4_DOWN
+    //% block="4 up"
+    _4Up = 16,  // MES_DPAD_BUTTON_4_UP
+    }
+declare namespace devices {
+}
+
+// Auto-generated. Do not edit. Really.

libs/microbit-devices/kind.json

@@ -3,11 +3,18 @@
     "description": "The BLE specific services",
     "files": [
         "README.md",
-        "devices.ts"
+        "enums.d.ts",
+        "shims.d.ts",
+        "devices.cpp"
     ],
     "public": true,
     "dependencies": {
         "microbit": "file:../microbit"
     },
+    "microbit": {
+        "config": {
+            "MICROBIT_BLE_ENABLED": "1"
+        }
+    },
     "installedVersion": "zakvul"
 }

libs/microbit-devices/shims.d.ts

@@ -0,0 +1,67 @@
+// Auto-generated. Do not edit.
+
+
+
+    //% color=156 weight=80
+declare namespace devices {
+
+    /**
+     * Sends a ``camera`` command to the parent device.
+     * @param event TODO
+     */
+    //% weight=30 help=devices/tell-camera-to
+    //% blockId=devices_camera icon="\uf030" block="tell camera to|%property" blockGap=8 shim=devices::tellCameraTo
+    function tellCameraTo(event: MesCameraEvent): void;
+
+    /**
+     * Sends a ``remote control`` command to the parent device.
+     * @param event TODO
+     */
+    //% weight=29 help=devices/tell-remote-control-to
+    //% blockId=devices_remote_control block="tell remote control to|%property" blockGap=14 icon="\uf144" shim=devices::tellRemoteControlTo
+    function tellRemoteControlTo(event: MesRemoteControlEvent): void;
+
+    /**
+     * Sends an ``alert`` command to the parent device.
+     * @param event TODO
+     */
+    //% weight=27 help=devices/raise-alert-to
+    //% blockId=devices_alert block="raise alert to|%property" icon="\uf0f3" shim=devices::raiseAlertTo
+    function raiseAlertTo(event: MesAlertEvent): void;
+
+    /**
+     * Registers code to run when the device notifies about a particular event.
+     * @param event TODO
+     * @param body TODO
+     */
+    //% help=devices/on-notified weight=26
+    //% blockId=devices_device_info_event block="on notified" icon="\uf10a" shim=devices::onNotified
+    function onNotified(event: MesDeviceInfo, body: () => void): void;
+
+    /**
+     * Register code to run when the micro:bit receives a command from the paired gamepad.
+     * @param name TODO
+     * @param body TODO
+     */
+    //% help=devices/on-gamepad-button weight=40
+    //% weight=25
+    //% blockId=devices_gamepad_event block="on gamepad button|%NAME" icon="\uf11b" shim=devices::onGamepadButton
+    function onGamepadButton(name: MesDpadButtonInfo, body: () => void): void;
+
+    /**
+     * Returns the last signal strength reported by the paired device.
+     */
+    //% help=devices/signal-strength weight=24
+    //% blockId=devices_signal_strength block="signal strength" blockGap=14 icon="\uf012" blockGap=14 shim=devices::signalStrength
+    function signalStrength(): number;
+
+    /**
+     * Registers code to run when the device notifies about a change of signal strength.
+     * @param body TODO
+     */
+    //% weight=23 help=devices/on-signal-strength-changed
+    //% blockId=devices_signal_strength_changed_event block="on signal strength changed" icon="\uf012" shim=devices::onSignalStrengthChanged
+    function onSignalStrengthChanged(body: () => void): void;
+}
+
+// Auto-generated. Do not edit. Really.

libs/microbit-radio/enums.d.ts

@@ -0,0 +1,5 @@
+// Auto-generated. Do not edit.
+declare namespace radio {
+}
+
+// Auto-generated. Do not edit. Really.

libs/microbit-radio/kind.json

@@ -3,11 +3,19 @@
     "description": "The radio services",
     "files": [
         "README.md",
+        "shims.d.ts",
+        "enums.d.ts",
+        "radio.cpp",
         "radio.ts"
     ],
     "public": true,
     "dependencies": {
         "microbit": "file:../microbit"
     },
+    "microbit": {
+        "config": {
+            "MICROBIT_BLE_ENABLED": "0"
+        }
+    },
     "installedVersion": "rlfgis"
 }

libs/microbit-radio/radio.cpp

@@ -0,0 +1,124 @@
+#include "kindscript.h"
+
+using namespace kindscript;
+
+//% color=270 weight=34
+namespace radio {
+
+    // -------------------------------------------------------------------------
+    // Radio
+    // -------------------------------------------------------------------------    
+    bool radioEnabled = false;
+    PacketBuffer packet;
+    
+    int radioEnable() {
+        int r = uBit.radio.enable();
+        if (r != MICROBIT_OK) return r;
+        if (!radioEnabled) {
+            uBit.radio.setGroup(kindscript::programHash());
+            radioEnabled = true;
+        }
+        return r;
+    }
+
+    void broadcastMessage(int message) {
+        if (radioEnable() != MICROBIT_OK) return;
+        uBit.radio.event.eventReceived(MicroBitEvent(MES_BROADCAST_GENERAL_ID, message, CREATE_ONLY));
+    }
+        
+    void onBroadcastMessageReceived(int message, Action f) {
+        if (radioEnable() != MICROBIT_OK) return;
+        registerWithDal(MES_BROADCAST_GENERAL_ID, message, f);
+    }
+
+
+    /**
+     * Broadcasts 4 numbers over radio to any connected micro:bit in the group.
+     */
+    //% help=radio/send-numbers
+    //% weight=59
+    //% blockId=radio_datagram_send_numbers block="send numbers|0: %VALUE0|1: %VALUE1|2: %VALUE2|3: %VALUE3"
+    void sendNumbers(int value_0, int value_1, int value_2, int value_3) {
+        if (radioEnable() != MICROBIT_OK) return;
+        int buf[] = { value_0, value_1, value_2, value_3 };
+        uBit.radio.datagram.send((uint8_t*)buf, 4*sizeof(int));
+    }
+
+    /**
+     * Registers code to run when a packet is received over radio.
+     */
+    //% help=radio/on-data-received
+    //% weight=50
+    //% blockId=radio_datagram_received_event block="on data received" blockGap=8
+    void onDataReceived(Action body) {
+        if (radioEnable() != MICROBIT_OK) return;
+        registerWithDal(MICROBIT_ID_RADIO, MICROBIT_RADIO_EVT_DATAGRAM, body);    
+    }
+
+    /**
+     * Reads a number at a given index, between ``0`` and ``3``, from the packet received by ``receive number``. Not supported in simulator.
+     * @param index index of the number to read from 0 to 3. 1 eg
+     */
+    //% help=radio/received-number-at
+    //% weight=45
+    //% blockId=radio_datagram_received_number_at block="receive number|at %VALUE" blockGap=8
+    int receivedNumberAt(int index) {
+        if (radioEnable() != MICROBIT_OK) return 0;
+        if (0 <= index && index < packet.length() / 4) {
+            // packet.getBytes() is not aligned
+            int r;
+            memcpy(&r, packet.getBytes() + index * 4, 4);
+            return r;
+        }
+        return 0;
+    }
+
+    /**
+     * Reads the next packet as a number from the radio queue.
+     */
+    //% help=radio/receive-number
+    //% weight=46
+    //% blockId=radio_datagram_receive block="receive number" blockGap=8
+    int receiveNumber()
+    {
+        if (radioEnable() != MICROBIT_OK) return 0;
+        packet = uBit.radio.datagram.recv();
+        return receivedNumberAt(0);
+    }
+
+    /**
+     * Gets the received signal strength indicator (RSSI) from the packet received by ``receive number``. Not supported in simulator.
+     * namespace=radio
+     */
+    //% help=radio/received-signal-strength
+    //% weight=40
+    //% blockId=radio_datagram_rssi block="received signal strength"
+    int receivedSignalStrength() {
+        if (radioEnable() != MICROBIT_OK) return 0;
+        return packet.getRSSI();
+    }
+
+    /**
+     * Sets the group id for radio communications. A micro:bit can only listen to one group ID at any time.
+     * @ param id the group id between ``0`` and ``255``, 1 eg
+     */
+    //% help=radio/set-group
+    //% weight=10
+    //% blockId=radio_set_group block="set group %ID"
+    void setGroup(int id) {
+        if (radioEnable() != MICROBIT_OK) return;
+        uBit.radio.setGroup(id);
+    }
+    
+    /**
+     * Change the output power level of the transmitter to the given value.
+    * @param power a value in the range 0..7, where 0 is the lowest power and 7 is the highest, 7 eg
+    */
+    //% help=radio/set-transmit-power
+    //% weight=9
+    //% blockId=radio_set_transmit_power block="set transmit power %power"
+    void setTransmitPower(int power) {
+        if (radioEnable() != MICROBIT_OK) return;
+        uBit.radio.setTransmitPower(power);
+    }
+}

libs/microbit-radio/radio.ts

@@ -9,89 +9,4 @@ namespace radio {
     export function sendNumber(value: number) : void { 
         sendNumbers(value, 0, 0, 0);
     }
-
-    /**
-     * Broadcasts 4 numbers over radio to any connected micro:bit in the group.
-     */
-    //% help=radio/send-numbers
-    //% shim=micro_bit::datagramSendNumbers
-    //% weight=59
-    //% blockId=radio_datagram_send_numbers block="send numbers|0: %VALUE0|1: %VALUE1|2: %VALUE2|3: %VALUE3"
-    export function sendNumbers(value_0: number, value_1: number, value_2: number, value_3: number) : void {
-        //        noBleWarning();
-    }
-
-    /**
-     * Registers code to run when a packet is received over radio.
-     */
-    //% help=radio/on-data-received
-    //% shim=micro_bit::onDatagramReceived
-    //% weight=50
-    //% blockId=radio_datagram_received_event block="on data received" blockGap=8
-    export function onDataReceived(body:Action) : void {
-        //      noBleWarning();
-    }
-
-    /**
-     * Reads the next packet as a number from the radio queue.
-     */
-    //% help=radio/receive-number
-    //% shim=micro_bit::datagramReceiveNumber
-    //% weight=46
-    //% blockId=radio_datagram_receive block="receive number" blockGap=8
-    export function receiveNumber() : number
-        {
-        //noBleWarning();
-        return 0;
-    }
-
-    /**
-     * Reads a number at a given index, between ``0`` and ``3``, from the packet received by ``receive number``. Not supported in simulator.
-     * @param index index of the number to read from 0 to 3. eg: 1
-     */
-    //% help=radio/received-number-at
-    //% shim=micro_bit::datagramGetNumber
-    //% weight=45
-    //% blockId=radio_datagram_received_number_at block="receive number|at %VALUE" blockGap=8
-    export function receivedNumberAt(index: number) : number {
-        /*      if (index < 0 || index >= 4) {
-            TD.simulator.warning("index should be between ``0`` and ``3``.");
-        }*/
-        return 0;
-    }
-
-    /**
-     * Gets the received signal strength indicator (RSSI) from the packet received by ``receive number``. Not supported in simulator.
-     * namespace=radio
-     */
-    //% help=radio/received-signal-strength
-    //% shim=micro_bit::datagramGetRSSI
-    //% weight=40
-    //% blockId=radio_datagram_rssi block="received signal strength"
-    export function receivedSignalStrength() : number {
-        return 0;
-    }
-
-    /**
-     * Sets the group id for radio communications. A micro:bit can only listen to one group ID at any time.
-     * @ param id the group id between ``0`` and ``255``, eg: 1
-     */
-    //% help=radio/set-group
-    //% shim=micro_bit::setGroup
-    //% weight=10
-    //% blockId=radio_set_group block="set group %ID"
-    export function setGroup(id: number) : void {
-    }
-    
-    /**
-     * Change the output power level of the transmitter to the given value.
-    * @param power a value in the range 0..7, where 0 is the lowest power and 7 is the highest, eg: 7
-    */
-    //% help=radio/set-transmit-power
-    //% shim=micro_bit::setTransmitPower
-    //% weight=9
-    //% blockId=radio_set_transmit_power block="set transmit power %power"
-    export function setTransmitPower(power:number) {
-        
-    }
 }

libs/microbit-radio/shims.d.ts

@@ -0,0 +1,69 @@
+// Auto-generated. Do not edit.
+
+
+
+    //% color=270 weight=34
+declare namespace radio {
+
+    /**
+     * Broadcasts 4 numbers over radio to any connected micro:bit in the group.
+     */
+    //% help=radio/send-numbers
+    //% weight=59
+    //% blockId=radio_datagram_send_numbers block="send numbers|0: %VALUE0|1: %VALUE1|2: %VALUE2|3: %VALUE3" shim=radio::sendNumbers
+    function sendNumbers(value_0: number, value_1: number, value_2: number, value_3: number): void;
+
+    /**
+     * Registers code to run when a packet is received over radio.
+     */
+    //% help=radio/on-data-received
+    //% weight=50
+    //% blockId=radio_datagram_received_event block="on data received" blockGap=8 shim=radio::onDataReceived
+    function onDataReceived(body: () => void): void;
+
+    /**
+     * Reads a number at a given index, between ``0`` and ``3``, from the packet received by ``receive number``. Not supported in simulator.
+     * @param index index of the number to read from 0 to 3. 1 eg
+     */
+    //% help=radio/received-number-at
+    //% weight=45
+    //% blockId=radio_datagram_received_number_at block="receive number|at %VALUE" blockGap=8 shim=radio::receivedNumberAt
+    function receivedNumberAt(index: number): number;
+
+    /**
+     * Reads the next packet as a number from the radio queue.
+     */
+    //% help=radio/receive-number
+    //% weight=46
+    //% blockId=radio_datagram_receive block="receive number" blockGap=8 shim=radio::receiveNumber
+    function receiveNumber(): number;
+
+    /**
+     * Gets the received signal strength indicator (RSSI) from the packet received by ``receive number``. Not supported in simulator.
+     * namespace=radio
+     */
+    //% help=radio/received-signal-strength
+    //% weight=40
+    //% blockId=radio_datagram_rssi block="received signal strength" shim=radio::receivedSignalStrength
+    function receivedSignalStrength(): number;
+
+    /**
+     * Sets the group id for radio communications. A micro:bit can only listen to one group ID at any time.
+     * @ param id the group id between ``0`` and ``255``, 1 eg
+     */
+    //% help=radio/set-group
+    //% weight=10
+    //% blockId=radio_set_group block="set group %ID" shim=radio::setGroup
+    function setGroup(id: number): void;
+
+    /**
+     * Change the output power level of the transmitter to the given value.
+     * @param power a value in the range 0..7, where 0 is the lowest power and 7 is the highest, 7 eg
+     */
+    //% help=radio/set-transmit-power
+    //% weight=9
+    //% blockId=radio_set_transmit_power block="set transmit power %power" shim=radio::setTransmitPower
+    function setTransmitPower(power: number): void;
+}
+
+// Auto-generated. Do not edit. Really.

libs/microbit/basic.cpp

@@ -1,4 +1,4 @@
-#include "BitVM.h"
+#include "ksbit.h"
 
 
 /**
@@ -38,7 +38,7 @@ namespace basic {
     //% blockId=device_show_leds
     //% block="show leds" icon="\uf00a"
     void showLeds(ImageLiteral leds, int interval = 400) {
-      uBit.display.print(MicroBitImage(getbytes(leds)), 0, 0, 0, interval);
+      uBit.display.print(MicroBitImage(imageBytes(leds)), 0, 0, 0, interval);
     }
 
     /**
@@ -80,24 +80,24 @@ namespace basic {
      * @param leds TODO
      * @param interval TODO
      */
-    //% help=basic/show-animation shim=micro_bit::showAnimation imageLiteral=1 async
+    //% help=basic/show-animation imageLiteral=1 async
     void showAnimation(ImageLiteral leds, int interval = 400) {
-      uBit.display.animate(MicroBitImage(getbytes(leds)), interval, 5, 0);
+      uBit.display.animate(MicroBitImage(imageBytes(leds)), interval, 5, 0);
     }
 
     /**
      * Draws an image on the LED screen.
      * @param leds TODO
      */
-    //% help=basic/plot-leds weight=80 shim=micro_bit::plotLeds
+    //% help=basic/plot-leds weight=80
     void plotLeds(ImageLiteral leds) {
-      MicroBitImage i(getbytes(leds));
+      MicroBitImage i(imageBytes(leds));
       uBit.display.print(i, 0, 0, 0, 0);
     }
 
     void forever_stub(void *a) {
       while (true) {
-        action::run((Action)a);
+        runAction0((Action)a);
         uBit.sleep(20);
       }
     }

libs/microbit/buffer.cpp

@@ -0,0 +1,155 @@
+#include "ksbit.h"
+
+enum class NumberFormat {
+    Int8LE = 1,
+    UInt8LE,
+    Int16LE,
+    UInt16LE,
+    Int32LE,
+    Int8BE,
+    UInt8BE,
+    Int16BE,
+    UInt16BE,
+    Int32BE,
+    // UInt32,
+};
+
+//% indexerGet=BufferMethods::getByte indexerSet=BufferMethods::setByte
+namespace BufferMethods {
+    //%
+    int getByte(Buffer buf, int off) {
+        return max(ManagedBuffer(buf).getByte(off), 0);
+    }
+
+    //%
+    void setByte(Buffer buf, int off, int v) {
+        ManagedBuffer(buf).setByte(off, v);
+    }
+
+    //%
+    uint8_t *getBytes(Buffer buf) {
+        return buf->payload;
+    }
+
+    /**
+     * Write a number in specified format in the buffer.
+     */
+    //%
+    void setNumber(Buffer buf, NumberFormat format, int offset, int value)
+    {
+        int8_t i8;
+        uint8_t u8;
+        int16_t i16;
+        uint16_t u16;
+        int32_t i32;
+
+        ManagedBuffer b(buf);
+
+        // Assume little endian
+        #define WRITEBYTES(isz, swap) isz = value; b.writeBytes(offset, (uint8_t*)&isz, sizeof(isz), swap); break
+
+        switch (format) {
+        case NumberFormat::Int8LE: WRITEBYTES(i8, false);
+        case NumberFormat::UInt8LE: WRITEBYTES(u8, false);
+        case NumberFormat::Int16LE: WRITEBYTES(i16, false);
+        case NumberFormat::UInt16LE: WRITEBYTES(u16, false);
+        case NumberFormat::Int32LE: WRITEBYTES(i32, false);
+        case NumberFormat::Int8BE: WRITEBYTES(i8, true);
+        case NumberFormat::UInt8BE: WRITEBYTES(u8, true);
+        case NumberFormat::Int16BE: WRITEBYTES(i16, true);
+        case NumberFormat::UInt16BE: WRITEBYTES(u16, true);
+        case NumberFormat::Int32BE: WRITEBYTES(i32, true);
+        }
+    }
+
+    /**
+     * Read a number in specified format from the buffer.
+     */
+    //%
+    int getNumber(Buffer buf, NumberFormat format, int offset)
+    {
+        int8_t i8;
+        uint8_t u8;
+        int16_t i16;
+        uint16_t u16;
+        int32_t i32;
+
+        ManagedBuffer b(buf);
+
+        // Assume little endian
+        #define READBYTES(isz, swap) b.readBytes((uint8_t*)&isz, offset, sizeof(isz), swap); return isz
+
+        switch (format) {
+        case NumberFormat::Int8LE: READBYTES(i8, false);
+        case NumberFormat::UInt8LE: READBYTES(u8, false);
+        case NumberFormat::Int16LE: READBYTES(i16, false);
+        case NumberFormat::UInt16LE: READBYTES(u16, false);
+        case NumberFormat::Int32LE: READBYTES(i32, false);
+        case NumberFormat::Int8BE: READBYTES(i8, true);
+        case NumberFormat::UInt8BE: READBYTES(u8, true);
+        case NumberFormat::Int16BE: READBYTES(i16, true);
+        case NumberFormat::UInt16BE: READBYTES(u16, true);
+        case NumberFormat::Int32BE: READBYTES(i32, true);
+        }
+
+        return 0;
+    }
+
+    /** Returns the length of a Buffer object. */
+    //% property
+    int length(Buffer s) {
+        return s->length;
+    }
+
+    /**
+     * Fill (a fragment) of the buffer with given value.
+     */
+    //%
+    void fill(Buffer buf, int value, int offset = 0, int length = -1)
+    {
+        ManagedBuffer(buf).fill(value, offset, length);
+    }
+
+    /**
+     * Return a copy of a fragment of a buffer.
+     */
+    //%
+    Buffer slice(Buffer buf, int offset = 0, int length = -1)
+    {
+        return ManagedBuffer(buf).slice(offset, length).leakData();
+    }
+
+    /**
+     * Shift buffer left in place, with zero padding.
+     * @param offset number of bytes to shift; use negative value to shift right
+     */
+    //%
+    void shift(Buffer buf, int offset)
+    {
+        ManagedBuffer(buf).shift(offset);
+    }
+
+    /**
+     * Rotate buffer left in place.
+     * @param offset number of bytes to shift; use negative value to shift right
+     */
+    //%
+    void rotate(Buffer buf, int offset)
+    {
+        ManagedBuffer(buf).rotate(offset);
+    }
+
+    // int readBytes(uint8_t *dst, int offset, int length, bool swapBytes = false) const;
+    // int writeBytes(int dstOffset, uint8_t *src, int length, bool swapBytes = false);
+
+    /**
+     * Write contents of `src` at `dstOffset` in current buffer.
+     */
+    //%
+    void write(Buffer buf, int dstOffset, Buffer src)
+    {
+        //Not supported, we only do up to 4 args :/
+        //void write(Buffer buf, int dstOffset, Buffer src, int srcOffset = 0, int length = -1)
+        ManagedBuffer(buf).writeBuffer(dstOffset, ManagedBuffer(src), 0, -1);
+    }
+}

libs/microbit/control.cpp

@@ -1,5 +1,119 @@
-#include "BitVM.h"
+#include "ksbit.h"
 
+/**
+ * How to create the event.
+ */
+enum class EventCreationMode {
+    /**
+     * MicroBitEvent is initialised, and no further processing takes place.
+     */
+    CreateOnly = CREATE_ONLY,
+    /**
+     * MicroBitEvent is initialised, and queued on the MicroBitMessageBus.
+     */
+    CreateAndQueue = CREATE_AND_QUEUE,
+    /**
+     * MicroBitEvent is initialised, and its event handlers are immediately fired (not suitable for use in interrupts!).
+     */
+    CreateAndFire = CREATE_AND_FIRE,
+};
+
+// note the trailing '_' in names - otherwise we get conflict with the pre-processor
+// this trailing underscore is removed by enums.d.ts generation process
+
+// TODO shouldn't these be renamed to something more sensible anyways?
+
+enum EventBusSource {
+    MICROBIT_ID_BUTTON_A_ = MICROBIT_ID_BUTTON_A,
+    MICROBIT_ID_BUTTON_B_ = MICROBIT_ID_BUTTON_B,
+    MICROBIT_ID_BUTTON_AB_ = MICROBIT_ID_BUTTON_AB,
+    MICROBIT_ID_RADIO_ = MICROBIT_ID_RADIO,
+    MICROBIT_ID_GESTURE_ = MICROBIT_ID_GESTURE,
+    MICROBIT_ID_ACCELEROMETER_ = MICROBIT_ID_ACCELEROMETER,
+    MICROBIT_ID_IO_P0_ = MICROBIT_ID_IO_P0,
+    MICROBIT_ID_IO_P1_ = MICROBIT_ID_IO_P1,
+    MICROBIT_ID_IO_P2_ = MICROBIT_ID_IO_P2,
+    MICROBIT_ID_IO_P3_ = MICROBIT_ID_IO_P3,
+    MICROBIT_ID_IO_P4_ = MICROBIT_ID_IO_P4,
+    MICROBIT_ID_IO_P5_ = MICROBIT_ID_IO_P5,
+    MICROBIT_ID_IO_P6_ = MICROBIT_ID_IO_P6,
+    MICROBIT_ID_IO_P7_ = MICROBIT_ID_IO_P7,
+    MICROBIT_ID_IO_P8_ = MICROBIT_ID_IO_P8,
+    MICROBIT_ID_IO_P9_ = MICROBIT_ID_IO_P9,
+    MICROBIT_ID_IO_P10_ = MICROBIT_ID_IO_P10,
+    MICROBIT_ID_IO_P11_ = MICROBIT_ID_IO_P11,
+    MICROBIT_ID_IO_P12_ = MICROBIT_ID_IO_P12,
+    MICROBIT_ID_IO_P13_ = MICROBIT_ID_IO_P13,
+    MICROBIT_ID_IO_P14_ = MICROBIT_ID_IO_P14,
+    MICROBIT_ID_IO_P15_ = MICROBIT_ID_IO_P15,
+    MICROBIT_ID_IO_P16_ = MICROBIT_ID_IO_P16,
+    MICROBIT_ID_IO_P19_ = MICROBIT_ID_IO_P19,
+    MICROBIT_ID_IO_P20_ = MICROBIT_ID_IO_P20,
+    MES_DEVICE_INFO_ID_ = MES_DEVICE_INFO_ID,
+    MES_SIGNAL_STRENGTH_ID_ = MES_SIGNAL_STRENGTH_ID,
+    MES_DPAD_CONTROLLER_ID_ = MES_DPAD_CONTROLLER_ID,
+    MES_BROADCAST_GENERAL_ID_ = MES_BROADCAST_GENERAL_ID,
+};
+
+enum EventBusValue {
+    MICROBIT_EVT_ANY_ = MICROBIT_EVT_ANY,
+    MICROBIT_BUTTON_EVT_CLICK_ = MICROBIT_BUTTON_EVT_CLICK,
+    MICROBIT_RADIO_EVT_DATAGRAM_ = MICROBIT_RADIO_EVT_DATAGRAM,
+    MICROBIT_ACCELEROMETER_EVT_DATA_UPDATE_ = MICROBIT_ACCELEROMETER_EVT_DATA_UPDATE,
+    MES_ALERT_EVT_ALARM1_ = MES_ALERT_EVT_ALARM1,
+    MES_ALERT_EVT_ALARM2_ = MES_ALERT_EVT_ALARM2,
+    MES_ALERT_EVT_ALARM3_ = MES_ALERT_EVT_ALARM3,
+    MES_ALERT_EVT_ALARM4_ = MES_ALERT_EVT_ALARM4,
+    MES_ALERT_EVT_ALARM5_ = MES_ALERT_EVT_ALARM5,
+    MES_ALERT_EVT_ALARM6_ = MES_ALERT_EVT_ALARM6,
+    MES_ALERT_EVT_DISPLAY_TOAST_ = MES_ALERT_EVT_DISPLAY_TOAST,
+    MES_ALERT_EVT_FIND_MY_PHONE_ = MES_ALERT_EVT_FIND_MY_PHONE,
+    MES_ALERT_EVT_PLAY_RINGTONE_ = MES_ALERT_EVT_PLAY_RINGTONE,
+    MES_ALERT_EVT_PLAY_SOUND_ = MES_ALERT_EVT_PLAY_SOUND,
+    MES_ALERT_EVT_VIBRATE_ = MES_ALERT_EVT_VIBRATE,
+    MES_CAMERA_EVT_LAUNCH_PHOTO_MODE_ = MES_CAMERA_EVT_LAUNCH_PHOTO_MODE,
+    MES_CAMERA_EVT_LAUNCH_VIDEO_MODE_ = MES_CAMERA_EVT_LAUNCH_VIDEO_MODE,
+    MES_CAMERA_EVT_START_VIDEO_CAPTURE_ = MES_CAMERA_EVT_START_VIDEO_CAPTURE,
+    MES_CAMERA_EVT_STOP_PHOTO_MODE_ = MES_CAMERA_EVT_STOP_PHOTO_MODE,
+    MES_CAMERA_EVT_STOP_VIDEO_CAPTURE_ = MES_CAMERA_EVT_STOP_VIDEO_CAPTURE,
+    MES_CAMERA_EVT_STOP_VIDEO_MODE_ = MES_CAMERA_EVT_STOP_VIDEO_MODE,
+    MES_CAMERA_EVT_TAKE_PHOTO_ = MES_CAMERA_EVT_TAKE_PHOTO,
+    MES_CAMERA_EVT_TOGGLE_FRONT_REAR_ = MES_CAMERA_EVT_TOGGLE_FRONT_REAR,
+    MES_DEVICE_DISPLAY_OFF_ = MES_DEVICE_DISPLAY_OFF,
+    MES_DEVICE_DISPLAY_ON_ = MES_DEVICE_DISPLAY_ON,
+    MES_DEVICE_GESTURE_DEVICE_SHAKEN_ = MES_DEVICE_GESTURE_DEVICE_SHAKEN,
+    MES_DEVICE_INCOMING_CALL_ = MES_DEVICE_INCOMING_CALL,
+    MES_DEVICE_INCOMING_MESSAGE_ = MES_DEVICE_INCOMING_MESSAGE,
+    MES_DEVICE_ORIENTATION_LANDSCAPE_ = MES_DEVICE_ORIENTATION_LANDSCAPE,
+    MES_DEVICE_ORIENTATION_PORTRAIT_ = MES_DEVICE_ORIENTATION_PORTRAIT,
+    MES_DPAD_BUTTON_1_DOWN_ = MES_DPAD_BUTTON_1_DOWN,
+    MES_DPAD_BUTTON_1_UP_ = MES_DPAD_BUTTON_1_UP,
+    MES_DPAD_BUTTON_2_DOWN_ = MES_DPAD_BUTTON_2_DOWN,
+    MES_DPAD_BUTTON_2_UP_ = MES_DPAD_BUTTON_2_UP,
+    MES_DPAD_BUTTON_3_DOWN_ = MES_DPAD_BUTTON_3_DOWN,
+    MES_DPAD_BUTTON_3_UP_ = MES_DPAD_BUTTON_3_UP,
+    MES_DPAD_BUTTON_4_DOWN_ = MES_DPAD_BUTTON_4_DOWN,
+    MES_DPAD_BUTTON_4_UP_ = MES_DPAD_BUTTON_4_UP,
+    MES_DPAD_BUTTON_A_DOWN_ = MES_DPAD_BUTTON_A_DOWN,
+    MES_DPAD_BUTTON_A_UP_ = MES_DPAD_BUTTON_A_UP,
+    MES_DPAD_BUTTON_B_DOWN_ = MES_DPAD_BUTTON_B_DOWN,
+    MES_DPAD_BUTTON_B_UP_ = MES_DPAD_BUTTON_B_UP,
+    MES_DPAD_BUTTON_C_DOWN_ = MES_DPAD_BUTTON_C_DOWN,
+    MES_DPAD_BUTTON_C_UP_ = MES_DPAD_BUTTON_C_UP,
+    MES_DPAD_BUTTON_D_DOWN_ = MES_DPAD_BUTTON_D_DOWN,
+    MES_DPAD_BUTTON_D_UP_ = MES_DPAD_BUTTON_D_UP,
+    MES_REMOTE_CONTROL_EVT_FORWARD_ = MES_REMOTE_CONTROL_EVT_FORWARD,
+    MES_REMOTE_CONTROL_EVT_NEXTTRACK_ = MES_REMOTE_CONTROL_EVT_NEXTTRACK,
+    MES_REMOTE_CONTROL_EVT_PAUSE_ = MES_REMOTE_CONTROL_EVT_PAUSE,
+    MES_REMOTE_CONTROL_EVT_PLAY_ = MES_REMOTE_CONTROL_EVT_PLAY,
+    MES_REMOTE_CONTROL_EVT_PREVTRACK_ = MES_REMOTE_CONTROL_EVT_PREVTRACK,
+    MES_REMOTE_CONTROL_EVT_REWIND_ = MES_REMOTE_CONTROL_EVT_REWIND,
+    MES_REMOTE_CONTROL_EVT_STOP_ = MES_REMOTE_CONTROL_EVT_STOP,
+    MES_REMOTE_CONTROL_EVT_VOLUMEDOWN_ = MES_REMOTE_CONTROL_EVT_VOLUMEDOWN,
+    MES_REMOTE_CONTROL_EVT_VOLUMEUP_ = MES_REMOTE_CONTROL_EVT_VOLUMEUP,
+};
+
+//% weight=1 color="#333333"
 namespace control {
     void fiberDone(void *a)
     {
@@ -13,10 +127,7 @@ namespace control {
     //% help=control/in-background
     //% blockId="control_in_background" block="run in background" blockGap=8
     void inBackground(Action a) {
-      if (a != 0) {
-        incr(a);
-        create_fiber((void(*)(void*))action::run, (void*)a, fiberDone);
-      }
+      runInBackground(a);
     }
 
     /**
@@ -27,4 +138,25 @@ namespace control {
     void reset() { 
       uBit.reset(); 
     }
+
+    /**
+     * Raises an event in the event bus.
+     * @param src ID of the MicroBit Component that generated the event e.g. MICROBIT_ID_BUTTON_A.
+     * @param value Component specific code indicating the cause of the event.
+     * @param mode optional definition of how the event should be processed after construction (default is CREATE_AND_QUEUE).
+     */
+    //% weight=21 blockGap=12 blockId="control_raise_event" block="raise event|from source %src=control_event_source|with value %value=control_event_value" blockExternalInputs=1
+    //% mode.defl=CREATE_AND_QUEUE
+    void raiseEvent(int src, int value, EventCreationMode mode) { 
+        MicroBitEvent evt(src, value, (MicroBitEventLaunchMode)mode); 
+    }
+
+    /**
+     * Raises an event in the event bus.
+     */
+    //% weight=20 blockGap=8 blockId="control_on_event" block="on event|from %src=control_event_source|with value %value=control_event_value" 
+    //% blockExternalInputs=1 blockStatement=1
+    void onEvent(int src, int value, Action handler) { 
+        registerWithDal(src, value, handler);
+    }
 }

libs/microbit/control.ts

@@ -1,195 +1,3 @@
-enum EventCreationMode {
-    /**
-     * MicroBitEvent is initialised, and no further processing takes place.
-     */
-    //% enumVal=CREATE_ONLY
-    CreateOnly,
-    /**
-     * MicroBitEvent is initialised, and queued on the MicroBitMessageBus.
-     */
-    //% enumVal=CREATE_AND_QUEUE    
-    CreateAndQueue,
-    /**
-     * MicroBitEvent is initialised, and its event handlers are immediately fired (not suitable for use in interrupts!).
-     */
-    //% enumVal=CREATE_AND_FIRE
-    CreateAndFire
-}
-
-enum EventBusSource {
-    //% enumVal=MICROBIT_ID_BUTTON_A
-    MICROBIT_ID_BUTTON_A,
-    //% enumVal=MICROBIT_ID_BUTTON_B
-    MICROBIT_ID_BUTTON_B,
-    //% enumVal=MICROBIT_ID_BUTTON_AB
-    MICROBIT_ID_BUTTON_AB,
-    //% enumVal=MICROBIT_ID_RADIO
-    MICROBIT_ID_RADIO,
-    //% enumVal=MICROBIT_ID_GESTURE
-    MICROBIT_ID_GESTURE,
-    //% enumVal=MICROBIT_ID_ACCELEROMETER
-    MICROBIT_ID_ACCELEROMETER,    
-    //% enumVal=MICROBIT_ID_IO_P0
-    MICROBIT_ID_IO_P0,
-    //% enumVal=MICROBIT_ID_IO_P1
-    MICROBIT_ID_IO_P1,
-    //% enumVal=MICROBIT_ID_IO_P2
-    MICROBIT_ID_IO_P2,
-    //% enumVal=MICROBIT_ID_IO_P3
-    MICROBIT_ID_IO_P3,
-    //% enumVal=MICROBIT_ID_IO_P4
-    MICROBIT_ID_IO_P4,
-    //% enumVal=MICROBIT_ID_IO_P5
-    MICROBIT_ID_IO_P5,
-    //% enumVal=MICROBIT_ID_IO_P6
-    MICROBIT_ID_IO_P6,
-    //% enumVal=MICROBIT_ID_IO_P7
-    MICROBIT_ID_IO_P7,
-    //% enumVal=MICROBIT_ID_IO_P8
-    MICROBIT_ID_IO_P8,
-    //% enumVal=MICROBIT_ID_IO_P9
-    MICROBIT_ID_IO_P9,
-    //% enumVal=MICROBIT_ID_IO_P10
-    MICROBIT_ID_IO_P10,
-    //% enumVal=MICROBIT_ID_IO_P11
-    MICROBIT_ID_IO_P11,
-    //% enumVal=MICROBIT_ID_IO_P12
-    MICROBIT_ID_IO_P12,
-    //% enumVal=MICROBIT_ID_IO_P13
-    MICROBIT_ID_IO_P13,
-    //% enumVal=MICROBIT_ID_IO_P14
-    MICROBIT_ID_IO_P14,
-    //% enumVal=MICROBIT_ID_IO_P15
-    MICROBIT_ID_IO_P15,
-    //% enumVal=MICROBIT_ID_IO_P16
-    MICROBIT_ID_IO_P16,
-    //% enumVal=MICROBIT_ID_IO_P19
-    MICROBIT_ID_IO_P19,
-    //% enumVal=MICROBIT_ID_IO_P20
-    MICROBIT_ID_IO_P20,
-    //% enumVal=MES_DEVICE_INFO_ID
-    MES_DEVICE_INFO_ID,
-    //% enumVal=MES_SIGNAL_STRENGTH_ID
-    MES_SIGNAL_STRENGTH_ID,
-    //% enumVal=MES_DPAD_CONTROLLER_ID
-    MES_DPAD_CONTROLLER_ID,
-    //% enumVal=MES_BROADCAST_GENERAL_ID
-    MES_BROADCAST_GENERAL_ID,
-}
-
-enum EventBusValue {
-    //% enumVal=MICROBIT_EVT_ANY
-    MICROBIT_EVT_ANY,
-    //% enumVal=MICROBIT_BUTTON_EVT_CLICK
-    MICROBIT_BUTTON_EVT_CLICK,
-    //% enumVal=MICROBIT_RADIO_EVT_DATAGRAM
-    MICROBIT_RADIO_EVT_DATAGRAM,
-    //% enumVal=MICROBIT_ACCELEROMETER_EVT_DATA_UPDATE
-    MICROBIT_ACCELEROMETER_EVT_DATA_UPDATE,
-    //% enumVal=MES_ALERT_EVT_ALARM1
-    MES_ALERT_EVT_ALARM1,
-    //% enumVal=MES_ALERT_EVT_ALARM2
-    MES_ALERT_EVT_ALARM2,
-    //% enumVal=MES_ALERT_EVT_ALARM3
-    MES_ALERT_EVT_ALARM3,
-    //% enumVal=MES_ALERT_EVT_ALARM4
-    MES_ALERT_EVT_ALARM4,
-    //% enumVal=MES_ALERT_EVT_ALARM5
-    MES_ALERT_EVT_ALARM5,
-    //% enumVal=MES_ALERT_EVT_ALARM6
-    MES_ALERT_EVT_ALARM6,
-    //% enumVal=MES_ALERT_EVT_DISPLAY_TOAST
-    MES_ALERT_EVT_DISPLAY_TOAST,
-    //% enumVal=MES_ALERT_EVT_FIND_MY_PHONE
-    MES_ALERT_EVT_FIND_MY_PHONE,
-    //% enumVal=MES_ALERT_EVT_PLAY_RINGTONE
-    MES_ALERT_EVT_PLAY_RINGTONE,
-    //% enumVal=MES_ALERT_EVT_PLAY_SOUND
-    MES_ALERT_EVT_PLAY_SOUND,
-    //% enumVal=MES_ALERT_EVT_VIBRATE
-    MES_ALERT_EVT_VIBRATE,
-    //% enumVal=MES_CAMERA_EVT_LAUNCH_PHOTO_MODE
-    MES_CAMERA_EVT_LAUNCH_PHOTO_MODE,
-    //% enumVal=MES_CAMERA_EVT_LAUNCH_VIDEO_MODE
-    MES_CAMERA_EVT_LAUNCH_VIDEO_MODE,
-    //% enumVal=MES_CAMERA_EVT_START_VIDEO_CAPTURE
-    MES_CAMERA_EVT_START_VIDEO_CAPTURE,
-    //% enumVal=MES_CAMERA_EVT_STOP_PHOTO_MODE
-    MES_CAMERA_EVT_STOP_PHOTO_MODE,
-    //% enumVal=MES_CAMERA_EVT_STOP_VIDEO_CAPTURE
-    MES_CAMERA_EVT_STOP_VIDEO_CAPTURE,
-    //% enumVal=MES_CAMERA_EVT_STOP_VIDEO_MODE
-    MES_CAMERA_EVT_STOP_VIDEO_MODE,
-    //% enumVal=MES_CAMERA_EVT_TAKE_PHOTO
-    MES_CAMERA_EVT_TAKE_PHOTO,
-    //% enumVal=MES_CAMERA_EVT_TOGGLE_FRONT_REAR
-    MES_CAMERA_EVT_TOGGLE_FRONT_REAR,
-    //% enumVal=MES_DEVICE_DISPLAY_OFF
-    MES_DEVICE_DISPLAY_OFF,
-    //% enumVal=MES_DEVICE_DISPLAY_ON
-    MES_DEVICE_DISPLAY_ON,
-    //% enumVal=MES_DEVICE_GESTURE_DEVICE_SHAKEN
-    MES_DEVICE_GESTURE_DEVICE_SHAKEN,
-    //% enumVal=MES_DEVICE_INCOMING_CALL
-    MES_DEVICE_INCOMING_CALL,
-    //% enumVal=MES_DEVICE_INCOMING_MESSAGE
-    MES_DEVICE_INCOMING_MESSAGE,
-    //% enumVal=MES_DEVICE_ORIENTATION_LANDSCAPE
-    MES_DEVICE_ORIENTATION_LANDSCAPE,
-    //% enumVal=MES_DEVICE_ORIENTATION_PORTRAIT
-    MES_DEVICE_ORIENTATION_PORTRAIT,
-    //% enumVal=MES_DPAD_BUTTON_1_DOWN
-    MES_DPAD_BUTTON_1_DOWN,
-    //% enumVal=MES_DPAD_BUTTON_1_UP
-    MES_DPAD_BUTTON_1_UP,
-    //% enumVal=MES_DPAD_BUTTON_2_DOWN
-    MES_DPAD_BUTTON_2_DOWN,
-    //% enumVal=MES_DPAD_BUTTON_2_UP
-    MES_DPAD_BUTTON_2_UP,
-    //% enumVal=MES_DPAD_BUTTON_3_DOWN
-    MES_DPAD_BUTTON_3_DOWN,
-    //% enumVal=MES_DPAD_BUTTON_3_UP
-    MES_DPAD_BUTTON_3_UP,
-    //% enumVal=MES_DPAD_BUTTON_4_DOWN
-    MES_DPAD_BUTTON_4_DOWN,
-    //% enumVal=MES_DPAD_BUTTON_4_UP
-    MES_DPAD_BUTTON_4_UP,
-    //% enumVal=MES_DPAD_BUTTON_A_DOWN
-    MES_DPAD_BUTTON_A_DOWN,
-    //% enumVal=MES_DPAD_BUTTON_A_UP
-    MES_DPAD_BUTTON_A_UP,
-    //% enumVal=MES_DPAD_BUTTON_B_DOWN
-    MES_DPAD_BUTTON_B_DOWN,
-    //% enumVal=MES_DPAD_BUTTON_B_UP
-    MES_DPAD_BUTTON_B_UP,
-    //% enumVal=MES_DPAD_BUTTON_C_DOWN
-    MES_DPAD_BUTTON_C_DOWN,
-    //% enumVal=MES_DPAD_BUTTON_C_UP
-    MES_DPAD_BUTTON_C_UP,
-    //% enumVal=MES_DPAD_BUTTON_D_DOWN
-    MES_DPAD_BUTTON_D_DOWN,
-    //% enumVal=MES_DPAD_BUTTON_D_UP
-    MES_DPAD_BUTTON_D_UP,
-    //% enumVal=MES_REMOTE_CONTROL_EVT_FORWARD
-    MES_REMOTE_CONTROL_EVT_FORWARD,
-    //% enumVal=MES_REMOTE_CONTROL_EVT_NEXTTRACK
-    MES_REMOTE_CONTROL_EVT_NEXTTRACK,
-    //% enumVal=MES_REMOTE_CONTROL_EVT_PAUSE
-    MES_REMOTE_CONTROL_EVT_PAUSE,
-    //% enumVal=MES_REMOTE_CONTROL_EVT_PLAY
-    MES_REMOTE_CONTROL_EVT_PLAY,
-    //% enumVal=MES_REMOTE_CONTROL_EVT_PREVTRACK
-    MES_REMOTE_CONTROL_EVT_PREVTRACK,
-    //% enumVal=MES_REMOTE_CONTROL_EVT_REWIND
-    MES_REMOTE_CONTROL_EVT_REWIND,
-    //% enumVal=MES_REMOTE_CONTROL_EVT_STOP
-    MES_REMOTE_CONTROL_EVT_STOP,
-    //% enumVal=MES_REMOTE_CONTROL_EVT_VOLUMEDOWN
-    MES_REMOTE_CONTROL_EVT_VOLUMEDOWN,
-    //% enumVal=MES_REMOTE_CONTROL_EVT_VOLUMEUP
-    MES_REMOTE_CONTROL_EVT_VOLUMEUP,
-}
-
 //% weight=1 color="#333333"
 namespace control {
 
@@ -207,22 +15,4 @@ namespace control {
     export function eventValue(id: EventBusValue) : number {
         return id;
     }
-
-    /**
-     * Raises an event in the event bus.
-     * @param src ID of the MicroBit Component that generated the event e.g. MICROBIT_ID_BUTTON_A.
-     * @param value Component specific code indicating the cause of the event.
-     * @param mode optional definition of how the event should be processed after construction (default is CREATE_AND_QUEUE).
-     */
-    // shim=micro_bit::busRaiseEvent
-    //% weight=21 blockGap=12 blockId="control_raise_event" block="raise event|from source %src=control_event_source|with value %value=control_event_value" blockExternalInputs=1
-    export function raiseEvent(src: number, value: number, mode: EventCreationMode = EventCreationMode.CreateAndQueue): void { }
-
-    /**
-     * Raises an event in the event bus.
-     */
-    // shim=micro_bit::onBusEvent
-    //% weight=20 blockGap=8 blockId="control_on_event" block="on event|from %src=control_event_source|with value %value=control_event_value" 
-    //% blockExternalInputs=1 blockStatement=1
-    export function onEvent(src: number, value: number, handler: Action): void { }
 }

libs/microbit/core.cpp

@@ -0,0 +1,336 @@
+#include "ksbit.h"
+#include <limits.h>
+
+namespace StringMethods {
+
+    /**
+      * Returns the character at the specified index.
+      * @param pos The zero-based index of the desired character.
+      */
+    //%
+    StringData *charAt(StringData *s, int pos) {
+      return ManagedString((char)ManagedString(s).charAt(pos)).leakData();
+    }
+
+    /** 
+      * Returns the Unicode value of the character at the specified location.
+      * @param index The zero-based index of the desired character. If there is no character at the specified index, NaN is returned.
+      */
+    //%
+    int charCodeAt(StringData *s, int index) {
+      return ManagedString(s).charAt(index);
+    }
+
+    /**
+      * Returns a string that contains the concatenation of two or more strings.
+      * @param other The string to append to the end of the string.  
+      */
+    //%
+    StringData *concat(StringData *s, StringData *other) {
+      ManagedString a(s), b(other);
+      return (a + b).leakData();
+    }
+
+    /**
+      * Determines whether relative order of two strings (in ASCII encoding).
+      * @param that String to compare to target string
+      */
+    //%
+    int compare(StringData *s, StringData *that) {
+        return strcmp(s->data, that->data);
+    }
+
+    /** Returns the length of a String object. */
+    //% property
+    int length(StringData *s) {
+        return s->len;
+    }
+}
+
+
+namespace BooleanMethods {
+    // Cache the string literals "true" and "false" when used.
+    // Note that the representation of booleans stays the usual C-one.
+    
+    static const char sTrue[]  __attribute__ ((aligned (4))) = "\xff\xff\x04\x00" "true\0";
+    static const char sFalse[] __attribute__ ((aligned (4))) = "\xff\xff\x05\x00" "false\0";
+
+    /**
+      * Returns a string representation of an object.
+      */
+    //%
+    StringData* toString(bool v)
+    {
+      if (v) {
+        return (StringData*)(void*)sTrue;
+      } else {
+        return (StringData*)(void*)sFalse;
+      }            
+    }
+
+    //%
+    bool bang(bool v) { return !v; }
+}
+
+namespace String_ {
+    /**
+      * Make a string from the given ASCII character code. 
+      */
+    //%
+    StringData *fromCharCode(int code)
+    {
+      return ManagedString((char)code).leakData();
+    }
+
+    //%
+    int toNumber(StringData *s) {
+      return atoi(s->data);
+    }
+
+    //%
+    StringData *mkEmpty()
+    {
+        return ManagedString::EmptyString.leakData();
+    }
+}
+
+namespace NumberMethods {
+    /**
+      * Returns a string representation of a number.
+      */
+    //%
+    StringData* toString(int n)
+    {
+      return ManagedString(n).leakData();
+    }
+}
+
+namespace NumberImpl {
+    // +, - and friends are handled directly by assembly instructions
+    // The comparisons are here as they are more code-size efficient
+    
+    //%
+    bool lt(int x, int y) { return x < y; }
+    //%
+    bool le(int x, int y) { return x <= y; }
+    //%
+    bool neq(int x, int y) { return x != y; }
+    //%
+    bool eq(int x, int y) { return x == y; }
+    //%
+    bool gt(int x, int y) { return x > y; }
+    //%
+    bool ge(int x, int y) { return x >= y; }
+
+    // These in fact call into C runtime on Cortex-M0 
+    //%
+    int div(int x, int y) { return x / y; }
+    //%
+    int mod(int x, int y) { return x % y; }
+}
+
+namespace Math_ {
+    /**
+      * Returns the value of a base expression taken to a specified power. 
+      * @param x The base value of the expression.
+      * @param y The exponent value of the expression.
+      */
+    //%
+    int pow(int x, int y)
+    {
+      if (y < 0)
+        return 0;
+      int r = 1;
+      while (y) {
+        if (y & 1)
+          r *= x;
+        y >>= 1;
+        x *= x;
+      }
+      return r;
+    }
+    
+    /** 
+     * Returns a pseudorandom number between 0 and `max`. 
+     */
+    //%
+    int random(int max) {
+      if (max == INT_MIN)
+        return -uBit.random(INT_MAX);
+      else if (max < 0)
+        return -uBit.random(-max);
+      else if (max == 0)
+        return 0;
+      else
+        return uBit.random(max);
+    }
+    
+    /**
+      * Returns the square root of a number.
+      * @param x A numeric expression.
+      */
+    //%
+    int sqrt(int x)
+    {
+      return ::sqrt(x);
+    }
+}
+
+namespace ArrayImpl {
+    //%
+    RefCollection *mk(uint32_t flags)
+    {
+      return new RefCollection(flags);
+    }
+    //%
+    int length(RefCollection *c) { return c->length(); }
+    //%
+    void push(RefCollection *c, uint32_t x) { c->push(x); }
+    //%
+    uint32_t getAt(RefCollection *c, int x) { return c->getAt(x); }
+    //%
+    void removeAt(RefCollection *c, int x) { c->removeAt(x); }
+    //%
+    void setAt(RefCollection *c, int x, uint32_t y) { c->setAt(x, y); }
+    //%
+    int indexOf(RefCollection *c, uint32_t x, int start) { return c->indexOf(x, start); }
+    //%
+    int removeElement(RefCollection *c, uint32_t x) { return c->removeElement(x); }
+}
+
+// Import some stuff directly
+namespace kindscript {
+  //%
+  void registerWithDal(int id, int event, Action a);
+  //%
+  void runAction0(Action a);
+  //%
+  void runAction1(Action a, int arg);
+  //%
+  Action mkAction(int reflen, int totallen, int startptr);
+  //%
+  RefRecord* mkRecord(int reflen, int totallen);
+  //%
+  void debugMemLeaks();
+  //%
+  int incr(uint32_t e);
+  //%
+  void decr(uint32_t e);
+  //%
+  uint32_t *allocate(uint16_t sz);
+  //%
+  int templateHash();
+  //%
+  int programHash();
+  //%
+  void *ptrOfLiteral(int offset);
+}
+
+namespace ksrt {
+  //%
+  uint32_t ldloc(RefLocal *r) {
+    return r->v;
+  }
+
+  //%
+  uint32_t ldlocRef(RefRefLocal *r) {
+    uint32_t tmp = r->v;
+    incr(tmp);
+    return tmp;
+  }
+
+  //%
+  void stloc(RefLocal *r, uint32_t v) {
+    r->v = v;
+  }
+
+  //%
+  void stlocRef(RefRefLocal *r, uint32_t v) {
+    decr(r->v);
+    r->v = v;
+  }
+
+  //%
+  RefLocal *mkloc() {
+    return new RefLocal();
+  }
+
+  //%
+  RefRefLocal *mklocRef() {
+    return new RefRefLocal();
+  }
+
+  // All of the functions below unref() self. This is for performance reasons -
+  // the code emitter will not emit the unrefs for them.
+ 
+  //%
+  uint32_t ldfld(RefRecord *r, int idx) {
+    auto tmp = r->ld(idx);
+    r->unref();
+    return tmp;
+  }
+
+  //%
+  uint32_t ldfldRef(RefRecord *r, int idx) {
+    auto tmp = r->ldref(idx);
+    r->unref();
+    return tmp;
+  }
+
+  //%
+  void stfld(RefRecord *r, int idx, uint32_t val) {
+    r->st(idx, val);
+    r->unref();
+  }
+
+  //%
+  void stfldRef(RefRecord *r, int idx, uint32_t val) {
+    r->stref(idx, val);
+    r->unref();
+  }
+
+  //%
+  uint32_t ldglb(int idx) {
+    check(0 <= idx && idx < numGlobals, ERR_OUT_OF_BOUNDS, 7);
+    return globals[idx];
+  }
+
+  //%
+  uint32_t ldglbRef(int idx) {
+    check(0 <= idx && idx < numGlobals, ERR_OUT_OF_BOUNDS, 7);
+    uint32_t tmp = globals[idx];
+    incr(tmp);
+    return tmp;
+  }
+
+  // note the idx comes last - it's more convenient that way in the emitter
+  //%
+  void stglb(uint32_t v, int idx)
+  {
+    check(0 <= idx && idx < numGlobals, ERR_OUT_OF_BOUNDS, 7);
+    globals[idx] = v;
+  }
+
+  //%
+  void stglbRef(uint32_t v, int idx)
+  {
+    check(0 <= idx && idx < numGlobals, ERR_OUT_OF_BOUNDS, 7);
+    decr(globals[idx]);
+    globals[idx] = v;
+  }
+
+  // Store a captured local in a closure. It returns the action, so it can be chained.
+  //%
+  RefAction *stclo(RefAction *a, int idx, uint32_t v)
+  {
+    //DBG("STCLO "); a->print(); DBG("@%d = %p\n", idx, (void*)v);
+    a->stCore(idx, v);
+    return a;
+  }
+
+  //%
+  void panic(int code)
+  {
+    uBit.panic(code);
+  }
+}

libs/microbit/core.d.ts

@@ -4,14 +4,14 @@ interface Array<T> {
     /**
       * Gets or sets the length of the array. This is a number one higher than the highest element defined in an array.
       */
-    //% shim=collection::count
+    //% shim=ArrayImpl::length
     length: number;
 
     /**
       * Appends new elements to an array.
       * @param items New elements of the Array.
       */
-    //% shim=collection::add
+    //% shim=ArrayImpl::push
     push(item: T): void;
     
     /**
@@ -41,11 +41,11 @@ interface Array<T> {
     slice(start: number, end: number): T[];
 
     /** Removes the first occurence of an object. Returns true if removed. */
-    //% shim=collection::remove
+    //% shim=ArrayImpl::removeElement
     removeElement(element:T) : boolean;
     
     /** Removes the object at position index. */
-    //% shim=collection::remove_at
+    //% shim=ArrayImpl::removeAt
     removeAt(idx:number) : void;
     
     
@@ -69,7 +69,7 @@ interface Array<T> {
       * @param searchElement The value to locate in the array.
       * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
       */
-    //% shim=collection::index_of
+    //% shim=ArrayImpl::indexOf
     indexOf(searchElement: T, fromIndex?: number): number;
 
 
@@ -78,159 +78,22 @@ interface Array<T> {
 
 
 interface String {
-
-    /**
-      * Returns the character at the specified index.
-      * @param pos The zero-based index of the desired character.
-      */
-    //% shim=string::at
-    charAt(pos: number): string;
-
-    /** 
-      * Returns the Unicode value of the character at the specified location.
-      * @param index The zero-based index of the desired character. If there is no character at the specified index, NaN is returned.
-      */
-    //% shim=string::code_at
-    charCodeAt(index: number): number;
-
-    /**
-      * Returns a string that contains the concatenation of two or more strings.
-      * @param strings The strings to append to the end of the string.  
-      */
-    //% shim=string::concat
-    concat(other: string): string;
-
-    /**
-      * Returns the position of the first occurrence of a substring. 
-      * @param searchString The substring to search for in the string
-      * @param position The index at which to begin searching the String object. If omitted, search starts at the beginning of the string.
-      */
-    indexOf(searchString: string, position?: number): number;
-
-    /**
-      * Returns the last occurrence of a substring in the string.
-      * @param searchString The substring to search for.
-      * @param position The index at which to begin searching. If omitted, the search begins at the end of the string.
-      */
-    lastIndexOf(searchString: string, position?: number): number;
-
-    /**
-      * Determines whether two strings are equivalent in the current locale.
-      * @param that String to compare to target string
-      */
-    localeCompare(that: string): number;
-
-    /**
-      * Returns a section of a string.
-      * @param start The index to the beginning of the specified portion of stringObj. 
-      * @param end The index to the end of the specified portion of stringObj. The substring includes the characters up to, but not including, the character indicated by end. 
-      * If this value is not specified, the substring continues to the end of stringObj.
-      */
-    slice(start?: number, end?: number): string;
-
-    /**
-      * Returns the substring at the specified location within a String object. 
-      * @param start The zero-based index number indicating the beginning of the substring.
-      * @param end Zero-based index number indicating the end of the substring. The substring includes the characters up to, but not including, the character indicated by end.
-      * If end is omitted, the characters from start through the end of the original string are returned.
-      */
-    substring(start: number, end?: number): string;
-
-    /** Converts all the alphabetic characters in a string to lowercase. */
-    toLowerCase(): string;
-
-    /** Converts all the alphabetic characters in a string to uppercase. */
-    toUpperCase(): string;
-
-    /** Returns the length of a String object. */
-    //% shim=string::count
-    length: number;
-
-    //% shim=string::at
     [index: number]: string;
 }
 
 
+interface Buffer {
+    [index: number]: number;
+}
+
 /**
   * Converts A string to an integer.
   * @param s A string to convert into a number.
   */
-  //% shim=string::to_number
+  //% shim=String_::toNumber
 declare function parseInt(s: string): number;
 
 interface Object {}
 interface Function {}
 interface IArguments {}
 interface RegExp {}
-
-interface Boolean {
-    /**
-      * Returns a string representation of an object.
-      */
-    //% shim=boolean::to_string
-    toString(): string;
-}
-
-declare namespace String {
-    /**
-      * Make a string from the given ASCII character code. 
-      */
-    //% shim=number::to_character
-    export function fromCharCode(code:number): string;
-}
-
-interface Number {
-    /**
-      * Returns a string representation of an object.
-      */
-    //% shim=number::to_string
-    toString(): string;
-}
-
-declare namespace Math {
-    /**
-      * Returns the absolute value of a number (the value without regard to whether it is positive or negative). 
-      * For example, the absolute value of -5 is the same as the absolute value of 5.
-      * @param x A numeric expression for which the absolute value is needed.
-      */
-    //% shim=math::abs
-    export function abs(x: number): number;
-    
-    /**
-      * Returns the sign of the x, indicating whether x is positive, negative or zero.
-      * @param x The numeric expression to test
-      */
-    //% shim=math::sign
-    export function sign(x: number): number;
-    
-    /**
-      * Returns the larger of two supplied numeric expressions. 
-      */
-    //% shim=math::max
-    export function max(a:number, b:number): number;
-    
-    /**
-      * Returns the smaller of two supplied numeric expressions. 
-      */
-    //% shim=math::min
-    export function min(a:number, b:number): number;
-    
-    /**
-      * Returns the value of a base expression taken to a specified power. 
-      * @param x The base value of the expression.
-      * @param y The exponent value of the expression.
-      */
-    //% shim=math::pow
-    export function pow(x: number, y: number): number;
-    
-    /** Returns a pseudorandom number between 0 and `max`. */
-    //% shim=math::random
-    export function random(max:number): number;
-    
-    /**
-      * Returns the square root of a number.
-      * @param x A numeric expression.
-      */
-    //% shim=math::sqrt
-    export function sqrt(x: number): number;
-}

libs/microbit/dal.d.ts

@@ -0,0 +1,378 @@
+// Auto-generated. Do not edit.
+declare const enum DAL {
+    // DynamicPwm.h
+    NO_PWMS = 3,
+    MICROBIT_DEFAULT_PWM_PERIOD = 20000,
+    PWM_PERSISTENCE_TRANSIENT = 1,
+    PWM_PERSISTENCE_PERSISTENT = 2,
+    // ErrorNo.h
+    MICROBIT_OK = 0,
+    MICROBIT_INVALID_PARAMETER = -1001,
+    MICROBIT_NOT_SUPPORTED = -1002,
+    MICROBIT_CALIBRATION_IN_PROGRESS = -1003,
+    MICROBIT_CALIBRATION_REQUIRED = -1004,
+    MICROBIT_NO_RESOURCES = -1005,
+    MICROBIT_BUSY = -1006,
+    MICROBIT_CANCELLED = -1007,
+    MICROBIT_I2C_ERROR = -1010,
+    MICROBIT_OOM = 20,
+    MICROBIT_HEAP_ERROR = 30,
+    MICROBIT_NULL_DEREFERENCE = 40,
+    // ExternalEvents.h
+    MICROBIT_ID_BLE = 1000,
+    // MESEvents.h
+    MES_REMOTE_CONTROL_ID = 1001,
+    MES_REMOTE_CONTROL_EVT_PLAY = 1,
+    MES_REMOTE_CONTROL_EVT_PAUSE = 2,
+    MES_REMOTE_CONTROL_EVT_STOP = 3,
+    MES_REMOTE_CONTROL_EVT_NEXTTRACK = 4,
+    MES_REMOTE_CONTROL_EVT_PREVTRACK = 5,
+    MES_REMOTE_CONTROL_EVT_FORWARD = 6,
+    MES_REMOTE_CONTROL_EVT_REWIND = 7,
+    MES_REMOTE_CONTROL_EVT_VOLUMEUP = 8,
+    MES_REMOTE_CONTROL_EVT_VOLUMEDOWN = 9,
+    MES_CAMERA_ID = 1002,
+    MES_CAMERA_EVT_LAUNCH_PHOTO_MODE = 1,
+    MES_CAMERA_EVT_LAUNCH_VIDEO_MODE = 2,
+    MES_CAMERA_EVT_TAKE_PHOTO = 3,
+    MES_CAMERA_EVT_START_VIDEO_CAPTURE = 4,
+    MES_CAMERA_EVT_STOP_VIDEO_CAPTURE = 5,
+    MES_CAMERA_EVT_STOP_PHOTO_MODE = 6,
+    MES_CAMERA_EVT_STOP_VIDEO_MODE = 7,
+    MES_CAMERA_EVT_TOGGLE_FRONT_REAR = 8,
+    MES_ALERTS_ID = 1004,
+    MES_ALERT_EVT_DISPLAY_TOAST = 1,
+    MES_ALERT_EVT_VIBRATE = 2,
+    MES_ALERT_EVT_PLAY_SOUND = 3,
+    MES_ALERT_EVT_PLAY_RINGTONE = 4,
+    MES_ALERT_EVT_FIND_MY_PHONE = 5,
+    MES_ALERT_EVT_ALARM1 = 6,
+    MES_ALERT_EVT_ALARM2 = 7,
+    MES_ALERT_EVT_ALARM3 = 8,
+    MES_ALERT_EVT_ALARM4 = 9,
+    MES_ALERT_EVT_ALARM5 = 10,
+    MES_ALERT_EVT_ALARM6 = 11,
+    MES_SIGNAL_STRENGTH_ID = 1101,
+    MES_SIGNAL_STRENGTH_EVT_NO_BAR = 1,
+    MES_SIGNAL_STRENGTH_EVT_ONE_BAR = 2,
+    MES_SIGNAL_STRENGTH_EVT_TWO_BAR = 3,
+    MES_SIGNAL_STRENGTH_EVT_THREE_BAR = 4,
+    MES_SIGNAL_STRENGTH_EVT_FOUR_BAR = 5,
+    MES_DEVICE_INFO_ID = 1103,
+    MES_DEVICE_ORIENTATION_LANDSCAPE = 1,
+    MES_DEVICE_ORIENTATION_PORTRAIT = 2,
+    MES_DEVICE_GESTURE_NONE = 3,
+    MES_DEVICE_GESTURE_DEVICE_SHAKEN = 4,
+    MES_DEVICE_DISPLAY_OFF = 5,
+    MES_DEVICE_DISPLAY_ON = 6,
+    MES_DEVICE_INCOMING_CALL = 7,
+    MES_DEVICE_INCOMING_MESSAGE = 8,
+    MES_DPAD_CONTROLLER_ID = 1104,
+    MES_DPAD_BUTTON_A_DOWN = 1,
+    MES_DPAD_BUTTON_A_UP = 2,
+    MES_DPAD_BUTTON_B_DOWN = 3,
+    MES_DPAD_BUTTON_B_UP = 4,
+    MES_DPAD_BUTTON_C_DOWN = 5,
+    MES_DPAD_BUTTON_C_UP = 6,
+    MES_DPAD_BUTTON_D_DOWN = 7,
+    MES_DPAD_BUTTON_D_UP = 8,
+    MES_DPAD_BUTTON_1_DOWN = 9,
+    MES_DPAD_BUTTON_1_UP = 10,
+    MES_DPAD_BUTTON_2_DOWN = 11,
+    MES_DPAD_BUTTON_2_UP = 12,
+    MES_DPAD_BUTTON_3_DOWN = 13,
+    MES_DPAD_BUTTON_3_UP = 14,
+    MES_DPAD_BUTTON_4_DOWN = 15,
+    MES_DPAD_BUTTON_4_UP = 16,
+    MES_BROADCAST_GENERAL_ID = 2000,
+    // ManagedString.h
+    // ManagedType.h
+    // Matrix4.h
+    // MemberFunctionCallback.h
+    // MicroBit.h
+    MICROBIT_FLAG_SCHEDULER_RUNNING = 0x00000001,
+    MICROBIT_FLAG_ACCELEROMETER_RUNNING = 0x00000002,
+    MICROBIT_FLAG_DISPLAY_RUNNING = 0x00000004,
+    MICROBIT_FLAG_COMPASS_RUNNING = 0x00000008,
+    MICROBIT_NAME_LENGTH = 5,
+    MICROBIT_NAME_CODE_LETTERS = 5,
+    NRF51822_RNG_ADDRESS = 0x4000D000,
+    // MicroBitAccelerometer.h
+    MICROBIT_ACCEL_PITCH_ROLL_VALID = 0x01,
+    MMA8653_DEFAULT_ADDR = 0x3A,
+    MMA8653_STATUS = 0x00,
+    MMA8653_OUT_X_MSB = 0x01,
+    MMA8653_WHOAMI = 0x0D,
+    MMA8653_XYZ_DATA_CFG = 0x0E,
+    MMA8653_CTRL_REG1 = 0x2A,
+    MMA8653_CTRL_REG2 = 0x2B,
+    MMA8653_CTRL_REG3 = 0x2C,
+    MMA8653_CTRL_REG4 = 0x2D,
+    MMA8653_CTRL_REG5 = 0x2E,
+    MMA8653_WHOAMI_VAL = 0x5A,
+    MMA8653_SAMPLE_RANGES = 3,
+    MMA8653_SAMPLE_RATES = 8,
+    MICROBIT_ACCELEROMETER_EVT_DATA_UPDATE = 1,
+    MICROBIT_ACCELEROMETER_EVT_TILT_UP = 1,
+    MICROBIT_ACCELEROMETER_EVT_TILT_DOWN = 2,
+    MICROBIT_ACCELEROMETER_EVT_TILT_LEFT = 3,
+    MICROBIT_ACCELEROMETER_EVT_TILT_RIGHT = 4,
+    MICROBIT_ACCELEROMETER_EVT_FACE_UP = 5,
+    MICROBIT_ACCELEROMETER_EVT_FACE_DOWN = 6,
+    MICROBIT_ACCELEROMETER_EVT_FREEFALL = 7,
+    MICROBIT_ACCELEROMETER_EVT_3G = 8,
+    MICROBIT_ACCELEROMETER_EVT_6G = 9,
+    MICROBIT_ACCELEROMETER_EVT_8G = 10,
+    MICROBIT_ACCELEROMETER_EVT_SHAKE = 11,
+    MICROBIT_ACCELEROMETER_REST_TOLERANCE = 200,
+    MICROBIT_ACCELEROMETER_TILT_TOLERANCE = 200,
+    MICROBIT_ACCELEROMETER_FREEFALL_TOLERANCE = 400,
+    MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE = 1000,
+    MICROBIT_ACCELEROMETER_3G_TOLERANCE = 3072,
+    MICROBIT_ACCELEROMETER_6G_TOLERANCE = 6144,
+    MICROBIT_ACCELEROMETER_8G_TOLERANCE = 8192,
+    MICROBIT_ACCELEROMETER_GESTURE_DAMPING = 10,
+    MICROBIT_ACCELEROMETER_SHAKE_DAMPING = 10,
+    MICROBIT_ACCELEROMETER_SHAKE_COUNT_THRESHOLD = 4,
+    GESTURE_NONE = 0,
+    GESTURE_UP = 1,
+    GESTURE_DOWN = 2,
+    GESTURE_LEFT = 3,
+    GESTURE_RIGHT = 4,
+    GESTURE_FACE_UP = 5,
+    GESTURE_FACE_DOWN = 6,
+    GESTURE_FREEFALL = 7,
+    GESTURE_3G = 8,
+    GESTURE_6G = 9,
+    GESTURE_8G = 10,
+    GESTURE_SHAKE = 11,
+    // MicroBitAccelerometerService.h
+    // MicroBitBLEManager.h
+    MICROBIT_BLE_PAIR_REQUEST = 0x01,
+    MICROBIT_BLE_PAIR_COMPLETE = 0x02,
+    MICROBIT_BLE_PAIR_PASSCODE = 0x04,
+    MICROBIT_BLE_PAIR_SUCCESSFUL = 0x08,
+    MICROBIT_BLE_PAIRING_TIMEOUT = 90,
+    MICROBIT_BLE_POWER_LEVELS = 8,
+    MICROBIT_BLE_MAXIMUM_BONDS = 4,
+    // MicroBitButton.h
+    MICROBIT_BUTTON_EVT_DOWN = 1,
+    MICROBIT_BUTTON_EVT_UP = 2,
+    MICROBIT_BUTTON_EVT_CLICK = 3,
+    MICROBIT_BUTTON_EVT_LONG_CLICK = 4,
+    MICROBIT_BUTTON_EVT_HOLD = 5,
+    MICROBIT_BUTTON_EVT_DOUBLE_CLICK = 6,
+    MICROBIT_BUTTON_LONG_CLICK_TIME = 1000,
+    MICROBIT_BUTTON_HOLD_TIME = 1500,
+    MICROBIT_BUTTON_STATE = 1,
+    MICROBIT_BUTTON_STATE_HOLD_TRIGGERED = 2,
+    MICROBIT_BUTTON_STATE_CLICK = 4,
+    MICROBIT_BUTTON_STATE_LONG_CLICK = 8,
+    MICROBIT_BUTTON_SIGMA_MIN = 0,
+    MICROBIT_BUTTON_SIGMA_MAX = 12,
+    MICROBIT_BUTTON_SIGMA_THRESH_HI = 8,
+    MICROBIT_BUTTON_SIGMA_THRESH_LO = 2,
+    MICROBIT_BUTTON_DOUBLE_CLICK_THRESH = 50,
+    MICROBIT_BUTTON_SIMPLE_EVENTS = 0,
+    MICROBIT_BUTTON_ALL_EVENTS = 1,
+    // MicroBitButtonService.h
+    // MicroBitCompass.h
+    MAG3110_DEFAULT_ADDR = 0x1D,
+    MAG_DR_STATUS = 0x00,
+    MAG_OUT_X_MSB = 0x01,
+    MAG_OUT_X_LSB = 0x02,
+    MAG_OUT_Y_MSB = 0x03,
+    MAG_OUT_Y_LSB = 0x04,
+    MAG_OUT_Z_MSB = 0x05,
+    MAG_OUT_Z_LSB = 0x06,
+    MAG_WHOAMI = 0x07,
+    MAG_SYSMOD = 0x08,
+    MAG_OFF_X_MSB = 0x09,
+    MAG_OFF_X_LSB = 0x0A,
+    MAG_OFF_Y_MSB = 0x0B,
+    MAG_OFF_Y_LSB = 0x0C,
+    MAG_OFF_Z_MSB = 0x0D,
+    MAG_OFF_Z_LSB = 0x0E,
+    MAG_DIE_TEMP = 0x0F,
+    MAG_CTRL_REG1 = 0x10,
+    MAG_CTRL_REG2 = 0x11,
+    MAG3110_SAMPLE_RATES = 11,
+    MICROBIT_COMPASS_EVT_CAL_REQUIRED = 1,
+    MICROBIT_COMPASS_EVT_CAL_START = 2,
+    MICROBIT_COMPASS_EVT_CAL_END = 3,
+    MICROBIT_COMPASS_EVT_DATA_UPDATE = 4,
+    MICROBIT_COMPASS_EVT_CONFIG_NEEDED = 5,
+    MICROBIT_COMPASS_EVT_CALIBRATE = 6,
+    MICROBIT_COMPASS_STATUS_CALIBRATED = 1,
+    MICROBIT_COMPASS_STATUS_CALIBRATING = 2,
+    MAG3110_WHOAMI_VAL = 0xC4,
+    // MicroBitCompat.h
+    // MicroBitComponent.h
+    MICROBIT_ID_BUTTON_A = 1,
+    MICROBIT_ID_BUTTON_B = 2,
+    MICROBIT_ID_BUTTON_RESET = 3,
+    MICROBIT_ID_ACCELEROMETER = 4,
+    MICROBIT_ID_COMPASS = 5,
+    MICROBIT_ID_DISPLAY = 6,
+    MICROBIT_IO_PINS = 20,
+    MICROBIT_ID_IO_P0 = 7,
+    MICROBIT_ID_IO_P1 = 8,
+    MICROBIT_ID_IO_P2 = 9,
+    MICROBIT_ID_IO_P3 = 10,
+    MICROBIT_ID_IO_P4 = 11,
+    MICROBIT_ID_IO_P5 = 12,
+    MICROBIT_ID_IO_P6 = 13,
+    MICROBIT_ID_IO_P7 = 14,
+    MICROBIT_ID_IO_P8 = 15,
+    MICROBIT_ID_IO_P9 = 16,
+    MICROBIT_ID_IO_P10 = 17,
+    MICROBIT_ID_IO_P11 = 18,
+    MICROBIT_ID_IO_P12 = 19,
+    MICROBIT_ID_IO_P13 = 20,
+    MICROBIT_ID_IO_P14 = 21,
+    MICROBIT_ID_IO_P15 = 22,
+    MICROBIT_ID_IO_P16 = 23,
+    MICROBIT_ID_IO_P19 = 24,
+    MICROBIT_ID_IO_P20 = 25,
+    MICROBIT_ID_BUTTON_AB = 26,
+    MICROBIT_ID_GESTURE = 27,
+    MICROBIT_ID_THERMOMETER = 28,
+    MICROBIT_ID_RADIO = 29,
+    MICROBIT_ID_RADIO_DATA_READY = 30,
+    MICROBIT_ID_MULTIBUTTON_ATTACH = 31,
+    MICROBIT_ID_MESSAGE_BUS_LISTENER = 1021,
+    MICROBIT_ID_NOTIFY_ONE = 1022,
+    MICROBIT_ID_NOTIFY = 1023,
+    // MicroBitCoordinateSystem.h
+    RAW = 0,
+    SIMPLE_CARTESIAN = 1,
+    NORTH_EAST_DOWN = 2,
+    // MicroBitDFUService.h
+    MICROBIT_DFU_OPCODE_START_DFU = 1,
+    MICROBIT_DFU_OPCODE_START_PAIR = 2,
+    MICROBIT_DFU_HISTOGRAM_WIDTH = 5,
+    MICROBIT_DFU_HISTOGRAM_HEIGHT = 5,
+    // MicroBitDisplay.h
+    MICROBIT_DISPLAY_EVT_ANIMATION_COMPLETE = 1,
+    MICROBIT_DISPLAY_EVT_FREE = 2,
+    MICROBIT_DISPLAY_EVT_LIGHT_SENSE = 4,
+    MICROBIT_DISPLAY_WIDTH = 5,
+    MICROBIT_DISPLAY_HEIGHT = 5,
+    MICROBIT_DISPLAY_SPACING = 1,
+    MICROBIT_DISPLAY_ERROR_CHARS = 4,
+    MICROBIT_DISPLAY_GREYSCALE_BIT_DEPTH = 8,
+    MICROBIT_DISPLAY_ANIMATE_DEFAULT_POS = -255,
+    MICROBIT_DISPLAY_ROW_RESET = 0x20,
+    ANIMATION_MODE_NONE = 0,
+    ANIMATION_MODE_STOPPED = 1,
+    ANIMATION_MODE_SCROLL_TEXT = 2,
+    ANIMATION_MODE_PRINT_TEXT = 3,
+    ANIMATION_MODE_SCROLL_IMAGE = 4,
+    ANIMATION_MODE_ANIMATE_IMAGE = 5,
+    ANIMATION_MODE_PRINT_CHARACTER = 6,
+    DISPLAY_MODE_BLACK_AND_WHITE = 0,
+    DISPLAY_MODE_GREYSCALE = 1,
+    DISPLAY_MODE_BLACK_AND_WHITE_LIGHT_SENSE = 2,
+    MICROBIT_DISPLAY_ROTATION_0 = 0,
+    MICROBIT_DISPLAY_ROTATION_90 = 1,
+    MICROBIT_DISPLAY_ROTATION_180 = 2,
+    MICROBIT_DISPLAY_ROTATION_270 = 3,
+    // MicroBitEvent.h
+    CREATE_ONLY = 0,
+    CREATE_AND_QUEUE = 1,
+    CREATE_AND_FIRE = 2,
+    // MicroBitEventService.h
+    // MicroBitFiber.h
+    MICROBIT_FLAG_DATA_READY = 0x01,
+    MICROBIT_FIBER_FLAG_FOB = 0x01,
+    MICROBIT_FIBER_FLAG_PARENT = 0x02,
+    MICROBIT_FIBER_FLAG_CHILD = 0x04,
+    MICROBIT_FIBER_FLAG_DO_NOT_PAGE = 0x08,
+    // MicroBitFont.h
+    MICROBIT_FONT_WIDTH = 5,
+    MICROBIT_FONT_HEIGHT = 5,
+    MICROBIT_FONT_ASCII_START = 32,
+    MICROBIT_FONT_ASCII_END = 126,
+    // MicroBitHeapAllocator.h
+    MICROBIT_HEAP_COUNT = 2,
+    MICROBIT_HEAP_BLOCK_FREE = 0x80000000,
+    // MicroBitI2C.h
+    MICROBIT_I2C_MAX_RETRIES = 9,
+    // MicroBitIO.h
+    // MicroBitIOPinService.h
+    MICROBIT_IO_PIN_SERVICE_PINCOUNT = 20,
+    MICROBIT_IO_PIN_SERVICE_DATA_SIZE = 10,
+    // MicroBitImage.h
+    // MicroBitLEDService.h
+    // MicroBitLightSensor.h
+    MICROBIT_LIGHT_SENSOR_CHAN_NUM = 3,
+    MICROBIT_LIGHT_SENSOR_AN_SET_TIME = 4000,
+    MICROBIT_LIGHT_SENSOR_TICK_PERIOD = 5,
+    MICROBIT_LIGHT_SENSOR_MAX_VALUE = 338,
+    MICROBIT_LIGHT_SENSOR_MIN_VALUE = 75,
+    // MicroBitListener.h
+    MESSAGE_BUS_LISTENER_PARAMETERISED = 0x0001,
+    MESSAGE_BUS_LISTENER_METHOD = 0x0002,
+    MESSAGE_BUS_LISTENER_BUSY = 0x0004,
+    MESSAGE_BUS_LISTENER_REENTRANT = 0x0008,
+    MESSAGE_BUS_LISTENER_QUEUE_IF_BUSY = 0x0010,
+    MESSAGE_BUS_LISTENER_DROP_IF_BUSY = 0x0020,
+    MESSAGE_BUS_LISTENER_NONBLOCKING = 0x0040,
+    MESSAGE_BUS_LISTENER_URGENT = 0x0080,
+    MESSAGE_BUS_LISTENER_DELETING = 0x8000,
+    // MicroBitMagnetometerService.h
+    // MicroBitMatrixMaps.h
+    NO_CONN = 0,
+    // MicroBitMessageBus.h
+    MICROBIT_CONTROL_BUS_ID = 0,
+    MICROBIT_ID_ANY = 0,
+    MICROBIT_EVT_ANY = 0,
+    // MicroBitMultiButton.h
+    MICROBIT_MULTI_BUTTON_STATE_1 = 0x01,
+    MICROBIT_MULTI_BUTTON_STATE_2 = 0x02,
+    MICROBIT_MULTI_BUTTON_HOLD_TRIGGERED_1 = 0x04,
+    MICROBIT_MULTI_BUTTON_HOLD_TRIGGERED_2 = 0x08,
+    MICROBIT_MULTI_BUTTON_SUPRESSED_1 = 0X10,
+    MICROBIT_MULTI_BUTTON_SUPRESSED_2 = 0x20,
+    MICROBIT_MULTI_BUTTON_ATTACHED = 0x40,
+    // MicroBitPanic.h
+    // MicroBitPin.h
+    IO_STATUS_DIGITAL_IN = 0x01,
+    IO_STATUS_DIGITAL_OUT = 0x02,
+    IO_STATUS_ANALOG_IN = 0x04,
+    IO_STATUS_ANALOG_OUT = 0x08,
+    IO_STATUS_TOUCH_IN = 0x10,
+    IO_STATUS_EVENTBUS_ENABLED = 0x80,
+    MICROBIT_PIN_MAX_OUTPUT = 1023,
+    MICROBIT_PIN_MAX_SERVO_RANGE = 180,
+    MICROBIT_PIN_DEFAULT_SERVO_RANGE = 2000,
+    MICROBIT_PIN_DEFAULT_SERVO_CENTER = 1500,
+    PIN_CAPABILITY_DIGITAL = 0x01,
+    PIN_CAPABILITY_ANALOG = 0x02,
+    PIN_CAPABILITY_TOUCH = 0x04,
+    // MicroBitRadio.h
+    MICROBIT_RADIO_STATUS_INITIALISED = 0x0001,
+    MICROBIT_RADIO_BASE_ADDRESS = 0x75626974,
+    MICROBIT_RADIO_DEFAULT_GROUP = 0,
+    MICROBIT_RADIO_DEFAULT_TX_POWER = 6,
+    MICROBIT_RADIO_DEFAULT_FREQUENCY = 7,
+    MICROBIT_RADIO_MAX_PACKET_SIZE = 32,
+    MICROBIT_RADIO_HEADER_SIZE = 4,
+    MICROBIT_RADIO_MAXIMUM_RX_BUFFERS = 4,
+    MICROBIT_RADIO_PROTOCOL_DATAGRAM = 1,
+    MICROBIT_RADIO_PROTOCOL_EVENTBUS = 2,
+    MICROBIT_RADIO_EVT_DATAGRAM = 1,
+    // MicroBitRadioDatagram.h
+    // MicroBitRadioEvent.h
+    // MicroBitSerial.h
+    MICROBIT_SERIAL_DEFAULT_BAUD_RATE = 115200,
+    MICROBIT_SERIAL_BUFFER_SIZE = 20,
+    // MicroBitStorage.h
+    MICROBIT_STORAGE_CONFIG_MAGIC = 0xCAFECAFE,
+    // MicroBitTemperatureService.h
+    // MicroBitThermometer.h
+    MICROBIT_THERMOMETER_PERIOD = 1000,
+    MICROBIT_THERMOMETER_EVT_UPDATE = 1,
+    // PacketBuffer.h
+    // RefCounted.h
+}

libs/microbit/enums.d.ts

@@ -0,0 +1,289 @@
+// Auto-generated. Do not edit.
+declare namespace images {
+}
+declare namespace basic {
+}
+
+
+    declare enum Button {
+    A = 1,  // MICROBIT_ID_BUTTON_A
+    B = 2,  // MICROBIT_ID_BUTTON_B
+    //% block="A+B"
+    AB = 26,  // MICROBIT_ID_BUTTON_AB
+    }
+
+
+    declare enum Dimension {
+    //% block=x
+    X = 0,
+    //% block=y
+    Y = 1,
+    //% block=z
+    Z = 2,
+    //% block=strength
+    Strength = 3,
+    }
+
+
+    declare enum Rotation {
+    //% block=pitch
+    Pitch = 0,
+    //% block=roll
+    Roll = 1,
+    }
+
+
+    declare enum TouchPin {
+    P0 = 7,  // MICROBIT_ID_IO_P0
+    P1 = 8,  // MICROBIT_ID_IO_P1
+    P2 = 9,  // MICROBIT_ID_IO_P2
+    }
+
+
+    declare enum AcceleratorRange {
+    /**
+     * The accelerator measures forces up to 1 gravity
+     */
+    //%  block="1g"
+    OneG = 1,
+    /**
+     * The accelerator measures forces up to 2 gravity
+     */
+    //%  block="2g"
+    TwoG = 2,
+    /**
+     * The accelerator measures forces up to 4 gravity
+     */
+    //% block="4g"
+    FourG = 4,
+    /**
+     * The accelerator measures forces up to 8 gravity
+     */
+    //% block="8g"
+    EightG = 8,
+    }
+
+
+    declare enum Gesture {
+    /**
+     * Raised when shaken
+     */
+    //% block=shake
+    Shake = 11,  // GESTURE_SHAKE
+    /**
+     * Raised when the logo is upward and the screen is vertical
+     */
+    //% block="logo up"
+    LogoUp = 1,  // GESTURE_UP
+    /**
+     * Raised when the logo is downward and the screen is vertical
+     */
+    //% block="logo down"
+    LogoDown = 2,  // GESTURE_DOWN
+    /**
+     * Raised when the screen is pointing down and the board is horizontal
+     */
+    //% block="screen up"
+    ScreenUp = 5,  // GESTURE_FACE_UP
+    /**
+     * Raised when the screen is pointing up and the board is horizontal
+     */
+    //% block="screen down"
+    ScreenDown = 6,  // GESTURE_FACE_DOWN
+    /**
+     * Raised when the screen is pointing left
+     */
+    //% block="tilt left"
+    TiltLeft = 3,  // GESTURE_LEFT
+    /**
+     * Raised when the screen is pointing right
+     */
+    //% block="tilt right"
+    TiltRight = 4,  // GESTURE_RIGHT
+    /**
+     * Raised when the board is falling!
+     */
+    //% block="free fall"
+    FreeFall = 7,  // GESTURE_FREEFALL
+    }
+declare namespace input {
+}
+
+
+    /**
+     * How to create the event.
+     */
+
+    declare enum EventCreationMode {
+    /**
+     * MicroBitEvent is initialised, and no further processing takes place.
+     */
+    CreateOnly = 0,  // CREATE_ONLY
+    /**
+     * MicroBitEvent is initialised, and queued on the MicroBitMessageBus.
+     */
+    CreateAndQueue = 1,  // CREATE_AND_QUEUE
+    /**
+     * MicroBitEvent is initialised, and its event handlers are immediately fired (not suitable for use in interrupts!).
+     */
+    CreateAndFire = 2,  // CREATE_AND_FIRE
+    }
+
+
+    declare enum EventBusSource {
+    MICROBIT_ID_BUTTON_A = 1,  // MICROBIT_ID_BUTTON_A
+    MICROBIT_ID_BUTTON_B = 2,  // MICROBIT_ID_BUTTON_B
+    MICROBIT_ID_BUTTON_AB = 26,  // MICROBIT_ID_BUTTON_AB
+    MICROBIT_ID_RADIO = 29,  // MICROBIT_ID_RADIO
+    MICROBIT_ID_GESTURE = 27,  // MICROBIT_ID_GESTURE
+    MICROBIT_ID_ACCELEROMETER = 4,  // MICROBIT_ID_ACCELEROMETER
+    MICROBIT_ID_IO_P0 = 7,  // MICROBIT_ID_IO_P0
+    MICROBIT_ID_IO_P1 = 8,  // MICROBIT_ID_IO_P1
+    MICROBIT_ID_IO_P2 = 9,  // MICROBIT_ID_IO_P2
+    MICROBIT_ID_IO_P3 = 10,  // MICROBIT_ID_IO_P3
+    MICROBIT_ID_IO_P4 = 11,  // MICROBIT_ID_IO_P4
+    MICROBIT_ID_IO_P5 = 12,  // MICROBIT_ID_IO_P5
+    MICROBIT_ID_IO_P6 = 13,  // MICROBIT_ID_IO_P6
+    MICROBIT_ID_IO_P7 = 14,  // MICROBIT_ID_IO_P7
+    MICROBIT_ID_IO_P8 = 15,  // MICROBIT_ID_IO_P8
+    MICROBIT_ID_IO_P9 = 16,  // MICROBIT_ID_IO_P9
+    MICROBIT_ID_IO_P10 = 17,  // MICROBIT_ID_IO_P10
+    MICROBIT_ID_IO_P11 = 18,  // MICROBIT_ID_IO_P11
+    MICROBIT_ID_IO_P12 = 19,  // MICROBIT_ID_IO_P12
+    MICROBIT_ID_IO_P13 = 20,  // MICROBIT_ID_IO_P13
+    MICROBIT_ID_IO_P14 = 21,  // MICROBIT_ID_IO_P14
+    MICROBIT_ID_IO_P15 = 22,  // MICROBIT_ID_IO_P15
+    MICROBIT_ID_IO_P16 = 23,  // MICROBIT_ID_IO_P16
+    MICROBIT_ID_IO_P19 = 24,  // MICROBIT_ID_IO_P19
+    MICROBIT_ID_IO_P20 = 25,  // MICROBIT_ID_IO_P20
+    MES_DEVICE_INFO_ID = 1103,  // MES_DEVICE_INFO_ID
+    MES_SIGNAL_STRENGTH_ID = 1101,  // MES_SIGNAL_STRENGTH_ID
+    MES_DPAD_CONTROLLER_ID = 1104,  // MES_DPAD_CONTROLLER_ID
+    MES_BROADCAST_GENERAL_ID = 2000,  // MES_BROADCAST_GENERAL_ID
+    }
+
+
+    declare enum EventBusValue {
+    MICROBIT_EVT_ANY = 0,  // MICROBIT_EVT_ANY
+    MICROBIT_BUTTON_EVT_CLICK = 3,  // MICROBIT_BUTTON_EVT_CLICK
+    MICROBIT_RADIO_EVT_DATAGRAM = 1,  // MICROBIT_RADIO_EVT_DATAGRAM
+    MICROBIT_ACCELEROMETER_EVT_DATA_UPDATE = 1,  // MICROBIT_ACCELEROMETER_EVT_DATA_UPDATE
+    MES_ALERT_EVT_ALARM1 = 6,  // MES_ALERT_EVT_ALARM1
+    MES_ALERT_EVT_ALARM2 = 7,  // MES_ALERT_EVT_ALARM2
+    MES_ALERT_EVT_ALARM3 = 8,  // MES_ALERT_EVT_ALARM3
+    MES_ALERT_EVT_ALARM4 = 9,  // MES_ALERT_EVT_ALARM4
+    MES_ALERT_EVT_ALARM5 = 10,  // MES_ALERT_EVT_ALARM5
+    MES_ALERT_EVT_ALARM6 = 11,  // MES_ALERT_EVT_ALARM6
+    MES_ALERT_EVT_DISPLAY_TOAST = 1,  // MES_ALERT_EVT_DISPLAY_TOAST
+    MES_ALERT_EVT_FIND_MY_PHONE = 5,  // MES_ALERT_EVT_FIND_MY_PHONE
+    MES_ALERT_EVT_PLAY_RINGTONE = 4,  // MES_ALERT_EVT_PLAY_RINGTONE
+    MES_ALERT_EVT_PLAY_SOUND = 3,  // MES_ALERT_EVT_PLAY_SOUND
+    MES_ALERT_EVT_VIBRATE = 2,  // MES_ALERT_EVT_VIBRATE
+    MES_CAMERA_EVT_LAUNCH_PHOTO_MODE = 1,  // MES_CAMERA_EVT_LAUNCH_PHOTO_MODE
+    MES_CAMERA_EVT_LAUNCH_VIDEO_MODE = 2,  // MES_CAMERA_EVT_LAUNCH_VIDEO_MODE
+    MES_CAMERA_EVT_START_VIDEO_CAPTURE = 4,  // MES_CAMERA_EVT_START_VIDEO_CAPTURE
+    MES_CAMERA_EVT_STOP_PHOTO_MODE = 6,  // MES_CAMERA_EVT_STOP_PHOTO_MODE
+    MES_CAMERA_EVT_STOP_VIDEO_CAPTURE = 5,  // MES_CAMERA_EVT_STOP_VIDEO_CAPTURE
+    MES_CAMERA_EVT_STOP_VIDEO_MODE = 7,  // MES_CAMERA_EVT_STOP_VIDEO_MODE
+    MES_CAMERA_EVT_TAKE_PHOTO = 3,  // MES_CAMERA_EVT_TAKE_PHOTO
+    MES_CAMERA_EVT_TOGGLE_FRONT_REAR = 8,  // MES_CAMERA_EVT_TOGGLE_FRONT_REAR
+    MES_DEVICE_DISPLAY_OFF = 5,  // MES_DEVICE_DISPLAY_OFF
+    MES_DEVICE_DISPLAY_ON = 6,  // MES_DEVICE_DISPLAY_ON
+    MES_DEVICE_GESTURE_DEVICE_SHAKEN = 4,  // MES_DEVICE_GESTURE_DEVICE_SHAKEN
+    MES_DEVICE_INCOMING_CALL = 7,  // MES_DEVICE_INCOMING_CALL
+    MES_DEVICE_INCOMING_MESSAGE = 8,  // MES_DEVICE_INCOMING_MESSAGE
+    MES_DEVICE_ORIENTATION_LANDSCAPE = 1,  // MES_DEVICE_ORIENTATION_LANDSCAPE
+    MES_DEVICE_ORIENTATION_PORTRAIT = 2,  // MES_DEVICE_ORIENTATION_PORTRAIT
+    MES_DPAD_BUTTON_1_DOWN = 9,  // MES_DPAD_BUTTON_1_DOWN
+    MES_DPAD_BUTTON_1_UP = 10,  // MES_DPAD_BUTTON_1_UP
+    MES_DPAD_BUTTON_2_DOWN = 11,  // MES_DPAD_BUTTON_2_DOWN
+    MES_DPAD_BUTTON_2_UP = 12,  // MES_DPAD_BUTTON_2_UP
+    MES_DPAD_BUTTON_3_DOWN = 13,  // MES_DPAD_BUTTON_3_DOWN
+    MES_DPAD_BUTTON_3_UP = 14,  // MES_DPAD_BUTTON_3_UP
+    MES_DPAD_BUTTON_4_DOWN = 15,  // MES_DPAD_BUTTON_4_DOWN
+    MES_DPAD_BUTTON_4_UP = 16,  // MES_DPAD_BUTTON_4_UP
+    MES_DPAD_BUTTON_A_DOWN = 1,  // MES_DPAD_BUTTON_A_DOWN
+    MES_DPAD_BUTTON_A_UP = 2,  // MES_DPAD_BUTTON_A_UP
+    MES_DPAD_BUTTON_B_DOWN = 3,  // MES_DPAD_BUTTON_B_DOWN
+    MES_DPAD_BUTTON_B_UP = 4,  // MES_DPAD_BUTTON_B_UP
+    MES_DPAD_BUTTON_C_DOWN = 5,  // MES_DPAD_BUTTON_C_DOWN
+    MES_DPAD_BUTTON_C_UP = 6,  // MES_DPAD_BUTTON_C_UP
+    MES_DPAD_BUTTON_D_DOWN = 7,  // MES_DPAD_BUTTON_D_DOWN
+    MES_DPAD_BUTTON_D_UP = 8,  // MES_DPAD_BUTTON_D_UP
+    MES_REMOTE_CONTROL_EVT_FORWARD = 6,  // MES_REMOTE_CONTROL_EVT_FORWARD
+    MES_REMOTE_CONTROL_EVT_NEXTTRACK = 4,  // MES_REMOTE_CONTROL_EVT_NEXTTRACK
+    MES_REMOTE_CONTROL_EVT_PAUSE = 2,  // MES_REMOTE_CONTROL_EVT_PAUSE
+    MES_REMOTE_CONTROL_EVT_PLAY = 1,  // MES_REMOTE_CONTROL_EVT_PLAY
+    MES_REMOTE_CONTROL_EVT_PREVTRACK = 5,  // MES_REMOTE_CONTROL_EVT_PREVTRACK
+    MES_REMOTE_CONTROL_EVT_REWIND = 7,  // MES_REMOTE_CONTROL_EVT_REWIND
+    MES_REMOTE_CONTROL_EVT_STOP = 3,  // MES_REMOTE_CONTROL_EVT_STOP
+    MES_REMOTE_CONTROL_EVT_VOLUMEDOWN = 9,  // MES_REMOTE_CONTROL_EVT_VOLUMEDOWN
+    MES_REMOTE_CONTROL_EVT_VOLUMEUP = 8,  // MES_REMOTE_CONTROL_EVT_VOLUMEUP
+    }
+declare namespace control {
+}
+
+
+    declare enum DisplayMode {
+    //% block="black and white"
+    BackAndWhite = 0,  // DISPLAY_MODE_BLACK_AND_WHITE
+    //% block="greyscale"
+    Greyscale = 1,  // DISPLAY_MODE_GREYSCALE
+    // TODO DISPLAY_MODE_BLACK_AND_WHITE_LIGHT_SENSE
+    }
+declare namespace led {
+}
+
+
+    declare enum DigitalPin {
+    P0 = 7,  // MICROBIT_ID_IO_P0
+    P1 = 8,  // MICROBIT_ID_IO_P1
+    P2 = 9,  // MICROBIT_ID_IO_P2
+    P3 = 10,  // MICROBIT_ID_IO_P3
+    P4 = 11,  // MICROBIT_ID_IO_P4
+    P5 = 12,  // MICROBIT_ID_IO_P5
+    P6 = 13,  // MICROBIT_ID_IO_P6
+    P7 = 14,  // MICROBIT_ID_IO_P7
+    P8 = 15,  // MICROBIT_ID_IO_P8
+    P9 = 16,  // MICROBIT_ID_IO_P9
+    P10 = 17,  // MICROBIT_ID_IO_P10
+    P11 = 18,  // MICROBIT_ID_IO_P11
+    P12 = 19,  // MICROBIT_ID_IO_P12
+    P13 = 20,  // MICROBIT_ID_IO_P13
+    P14 = 21,  // MICROBIT_ID_IO_P14
+    P15 = 22,  // MICROBIT_ID_IO_P15
+    P16 = 23,  // MICROBIT_ID_IO_P16
+    P19 = 24,  // MICROBIT_ID_IO_P19
+    P20 = 25,  // MICROBIT_ID_IO_P20
+    }
+
+
+    declare enum AnalogPin {
+    P0 = 7,  // MICROBIT_ID_IO_P0
+    P1 = 8,  // MICROBIT_ID_IO_P1
+    P2 = 9,  // MICROBIT_ID_IO_P2
+    P3 = 10,  // MICROBIT_ID_IO_P3
+    P4 = 11,  // MICROBIT_ID_IO_P4
+    P10 = 17,  // MICROBIT_ID_IO_P10
+    }
+declare namespace pins {
+}
+declare namespace serial {
+}
+
+
+    declare enum NumberFormat {
+    Int8LE = 1,
+    UInt8LE = 2,
+    Int16LE = 3,
+    UInt16LE = 4,
+    Int32LE = 5,
+    Int8BE = 6,
+    UInt8BE = 7,
+    Int16BE = 8,
+    UInt16BE = 9,
+    Int32BE = 10,
+    // UInt32,
+    }
+
+// Auto-generated. Do not edit. Really.

libs/microbit/game.ts

@@ -28,7 +28,7 @@ namespace game {
     var _countdownPause: number = 0;
     var _level: number = 1;
     var _gameId: number = 0;
-    var img: images.Image;
+    var img: Image;
     var sprites: LedSprite[];
     
     /**
@@ -284,8 +284,8 @@ namespace game {
         private _blink: number;
 
         constructor(x: number, y: number) {
-            this._x = math.clamp(0, 4, x);
-            this._y = math.clamp(0, 4, y);
+            this._x = Math.clamp(0, 4, x);
+            this._y = Math.clamp(0, 4, y);
             this._dir = 90;
             this._brightness = 255;
             init();
@@ -322,8 +322,8 @@ namespace game {
                 this._x = this._x - leds;
                 this._y = this._y + leds;
             }
-            this._x = math.clamp(0, 4, this._x);
-            this._y = math.clamp(0, 4, this._y);
+            this._x = Math.clamp(0, 4, this._x);
+            this._y = Math.clamp(0, 4, this._y);
             plot();
         }
 
@@ -336,8 +336,8 @@ namespace game {
         public goTo(x: number, y: number): void {
             this._x = x;
             this._y = y;
-            this._x = math.clamp(0, 4, this._x);
-            this._y = math.clamp(0, 4, this._y);
+            this._x = Math.clamp(0, 4, this._x);
+            this._y = Math.clamp(0, 4, this._y);
             plot();
         }
 
@@ -594,7 +594,7 @@ namespace game {
          * @param brightness TODO
          */
         public setBrightness(brightness: number): void {
-            this._brightness = math.clamp(0, 255, brightness);
+            this._brightness = Math.clamp(0, 255, brightness);
             plot();
         }
 
@@ -639,7 +639,7 @@ namespace game {
          * @param ms TODO
          */
         public setBlink(ms: number): void {
-            this._blink = math.clamp(0, 10000, ms);
+            this._blink = Math.clamp(0, 10000, ms);
         }
 
         /**

libs/microbit/images.cpp

@@ -0,0 +1,85 @@
+#include "ksbit.h"
+
+//% color=45 weight=31
+namespace images {
+    /**
+     * Creates an image that fits on the LED screen.
+     */
+    //% weight=75 help=images/create-image
+    //% blockId=device_build_image block="create image"
+    Image createImage(ImageLiteral leds) {
+        return MicroBitImage(imageBytes(leds)).clone().leakData();
+    }
+
+    /**
+     * Creates an image with 2 frames.
+     */
+    //% weight=74 help=images/create-big-image
+    //% blockId=device_build_big_image block="create big image" imageLiteral=2
+    Image createBigImage(ImageLiteral leds) {
+        return createImage(leds);
+    }
+}
+
+namespace ImageMethods {
+    /**
+     * Shows an frame from the image at offset ``x offset``.
+     * @param xOffset TODO
+     */
+    //% help=images/show-image weight=80 async
+    //% BUGblockId=device_show_image_offset block="show image %sprite|at offset %offset" blockGap=8
+    void showImage(Image i, int xOffset = 0) {
+      uBit.display.print(MicroBitImage(i), -xOffset, 0, 0);
+    }
+    
+    /**
+     * Scrolls an image .
+     * @param frameOffset x offset moved on each animation step, eg: 5, 1, -1
+     * @param interval time between each animation step in milli seconds, eg: 200
+     */
+    //% help=images/show-image weight=79 async
+    //% BUGblockId=device_scroll_image block="scroll image %sprite|with offset %frameoffset|and interval (ms) %delay" blockGap=8
+    void scrollImage(Image id, int frameOffset = 0, int interval = 200) {
+      MicroBitImage i(id);
+      if (i.getWidth() <= 5)
+        showImage(id, 0);
+      else
+        uBit.display.animate(i, interval, frameOffset, 0);
+    }
+
+
+    /**
+     * Plots the image at a given column to the screen
+     */            
+    //% help=images/plot-image
+    void plotImage(Image i, int xOffset = 0) {
+      uBit.display.print(MicroBitImage(i), -xOffset, 0, 0, 0);
+    }
+
+    /**
+     * Sets all pixels off.
+     */
+    //% help=images/clear
+    void clear(Image i) {
+      MicroBitImage(i).clear();
+    }
+
+    /**
+     * Sets a specific pixel brightness at a given position
+     */
+    //% help=
+    void setPixelBrightness(Image i, int x, int y, int value) {
+      MicroBitImage(i).setPixelValue(x, y, value);
+    }
+
+
+    /**
+     * Gets the pixel brightness ([0..255]) at a given position
+     */
+    //% help=
+    int pixelBrightness(Image i, int x, int y) {
+      int pix = MicroBitImage(i).getPixelValue(x, y);
+      if (pix < 0) return 0;
+      return pix;
+    }
+}

libs/microbit/images.ts

@@ -1,63 +0,0 @@
-//% color=45 weight=31
-namespace images {
-    /**
-     * Creates an image that fits on the LED screen.
-     */
-    //% weight=75 help=images/create-image
-    //% blockId=device_build_image block="create image" imageLiteral=1
-    export function createImage(leds: string): Image {
-        return null;
-    }
-
-    /**
-     * Creates an image with 2 frames.
-     */
-    //% weight=74 help=images/create-big-image
-    //% blockId=device_build_big_image block="create big image" imageLiteral=2
-    export function createBigImage(leds: string): Image {
-        return null;
-    }
-    
-    export class Image {
-        /**
-         * Shows an frame from the image at offset ``x offset``.
-         * @param xOffset TODO
-         */
-        //% help=images/show-image weight=80 shim=micro_bit::showImage
-        //% blockId=device_show_image_offset block="show image %sprite|at offset %offset" blockGap=8
-        public showImage(xOffset: number = 0): void {}
-        
-        /**
-         * Scrolls an image .
-         * @param frameOffset x offset moved on each animation step, eg: 5, 1, -1
-         * @param interval time between each animation step in milli seconds, eg: 200
-         */
-        //% help=images/show-image weight=79 shim=micro_bit::scrollImage async
-        //% blockId=device_scroll_image block="scroll image %sprite|with offset %frameoffset|and interval (ms) %delay" blockGap=8
-        public scrollImage(frameOffset: number = 0, interval : number = 200) {            
-        }
-
-
-        /**
-         * Plots the image at a given column to the screen
-         */            
-        public plotImage(xOffset: number = 0): void {}
-
-        /**
-         * Sets all pixels off.
-         */
-        public clear(): void {}
-
-        /**
-         * Sets a specific pixel brightness at a given position
-         */
-        public setPixelBrightness(x: number, y: number, v: number): void {}
-
-        /**
-         * Gets the pixel brightness ([0..255]) at a given position
-         */
-        public pixelBrightness(x: number, y: number): number {
-            return 0;
-        }
-    }
-}

libs/microbit/input.cpp

@@ -0,0 +1,281 @@
+#include "ksbit.h"
+
+enum class Button {
+    A = MICROBIT_ID_BUTTON_A,
+    B = MICROBIT_ID_BUTTON_B,
+    //% block="A+B"
+    AB = MICROBIT_ID_BUTTON_AB,
+};
+
+enum class Dimension {
+    //% block=x
+    X = 0,
+    //% block=y
+    Y = 1,
+    //% block=z
+    Z = 2,
+    //% block=strength
+    Strength = 3,
+};
+
+enum class Rotation {
+    //% block=pitch
+    Pitch = 0,
+    //% block=roll
+    Roll = 1,
+};
+
+enum class TouchPin {
+    P0 = MICROBIT_ID_IO_P0,
+    P1 = MICROBIT_ID_IO_P1,
+    P2 = MICROBIT_ID_IO_P2,
+};
+
+enum class AcceleratorRange {
+    /**
+     * The accelerator measures forces up to 1 gravity
+     */
+    //%  block="1g"
+    OneG = 1,
+    /**
+     * The accelerator measures forces up to 2 gravity
+     */
+    //%  block="2g"
+    TwoG = 2,
+    /**
+     * The accelerator measures forces up to 4 gravity
+     */
+    //% block="4g"
+    FourG = 4,
+    /**
+     * The accelerator measures forces up to 8 gravity
+     */
+    //% block="8g"
+    EightG = 8
+};
+
+enum class Gesture {
+    /**
+     * Raised when shaken
+     */
+    //% block=shake
+    Shake = GESTURE_SHAKE,
+    /**
+     * Raised when the logo is upward and the screen is vertical
+     */
+    //% block="logo up"
+    LogoUp = GESTURE_UP,
+    /**
+     * Raised when the logo is downward and the screen is vertical
+     */
+    //% block="logo down"
+    LogoDown = GESTURE_DOWN,
+    /**
+     * Raised when the screen is pointing down and the board is horizontal
+     */
+    //% block="screen up"
+    ScreenUp = GESTURE_FACE_UP,
+    /**
+     * Raised when the screen is pointing up and the board is horizontal
+     */
+    //% block="screen down"
+    ScreenDown = GESTURE_FACE_DOWN,
+    /**
+     * Raised when the screen is pointing left
+     */
+    //% block="tilt left"
+    TiltLeft = GESTURE_LEFT,
+    /**
+     * Raised when the screen is pointing right
+     */
+    //% block="tilt right"
+    TiltRight = GESTURE_RIGHT,    
+    /**
+     * Raised when the board is falling!
+     */
+    //% block="free fall"
+    FreeFall = GESTURE_FREEFALL
+};
+
+//% color=300 weight=99
+namespace input {
+    /**
+     * Do something when a button (``A``, ``B`` or both ``A+B``) is pressed
+     * @param button TODO
+     * @param body TODO
+     */
+    //% help=input/on-button-pressed weight=85
+    //% blockId=device_button_event 
+    //% block="on button|%NAME|pressed" 
+    //% icon="\uf192"
+    void onButtonPressed(Button button, Action body) {
+        registerWithDal((int)button, MICROBIT_BUTTON_EVT_CLICK, body);
+    }
+
+    /**
+     * Attaches code to run when the screen is facing up.
+     * @param body TODO
+     */
+    //% help=input/on-gesture weight=84
+    //% blockId=device_gesture_event block="on |%NAME" icon="\uf135"
+    void onGesture(Gesture gesture, Action body) {
+        registerWithDal(MICROBIT_ID_GESTURE, (int)gesture, body);
+    }
+
+    /**
+     * Do something when a pin(``P0``, ``P1`` or both ``P2``) is pressed.
+     * @param name TODO
+     * @param body TODO
+     */
+    //% help=input/on-pin-pressed weight=83
+    //% blockId=device_pin_event block="on pin|%NAME|pressed" icon="\uf094"
+    void onPinPressed(TouchPin name, Action body) {
+        auto pin = getPin((int)name);
+        if (!pin) return;
+
+        // Forces the PIN to switch to makey-makey style detection.
+        pin->isTouched();
+        registerWithDal((int)name, MICROBIT_BUTTON_EVT_CLICK, body);
+    }
+
+    /**
+     * Get the button state (pressed or not) for ``A`` and ``B``.
+     */
+    //% help=input/button-is-pressed weight=57
+    //% block="button|%NAME|is pressed"
+    //% blockId=device_get_button2
+    //% icon="\uf192" blockGap=8
+    bool buttonIsPressed(Button button) {
+      if (button == Button::A)
+        return uBit.buttonA.isPressed();
+      else if (button == Button::B)
+        return uBit.buttonB.isPressed();
+      else if (button == Button::AB)
+        return uBit.buttonAB.isPressed();
+      return false;
+    }
+
+
+    /**
+     * Get the current compass compass heading in degrees.
+     */
+    //% help=input/compass-heading 
+    //% weight=56 icon="\uf14e"
+    //% blockId=device_heading block="compass heading (°)" blockGap=8
+    int compassHeading() {
+        return uBit.compass.heading();
+    }
+
+
+    /**
+     * Gets the temperature in Celsius degrees (°C).
+     */
+    //% weight=55 icon="\uf06d"
+    //% help=input/temperature
+    //% blockId=device_temperature block="temperature (°C)" blockGap=8
+    int temperature() {
+        return uBit.thermometer.getTemperature();
+    }
+
+    int getAccelerationStrength() {
+        double x = uBit.accelerometer.getX();
+        double y = uBit.accelerometer.getY();
+        double z = uBit.accelerometer.getZ();
+        return (int)sqrt(x*x+y*y+z*z);
+    }
+
+    /**
+     * Get the acceleration value in milli-gravitys (when the board is laying flat with the screen up, x=0, y=0 and z=-1024)
+     * @param dimension TODO
+     */
+    //% help=input/acceleration weight=54 icon="\uf135"
+    //% blockId=device_acceleration block="acceleration (mg)|%NAME" blockGap=8
+    int acceleration(Dimension dimension) {
+      switch (dimension) {
+      case Dimension::X: return uBit.accelerometer.getX();
+      case Dimension::Y: return uBit.accelerometer.getY();
+      case Dimension::Z: return uBit.accelerometer.getZ();
+      case Dimension::Strength: return getAccelerationStrength();
+      }
+      return 0;
+    }
+
+
+    /**
+     * Reads the light level applied to the LED screen in a range from ``0`` (dark) to ``255`` bright. In the simulator, the ``acceleration y`` is used to emulate this value.
+     */
+    //% help=input/light-level weight=53
+    //% blockId=device_get_light_level block="light level" blockGap=8 icon="\uf185"
+    int lightLevel() {
+        return uBit.display.readLightLevel();
+    }
+
+    /**
+     * The pitch of the device, rotation along the ``x-axis``, in degrees.
+     * @param kind TODO
+     */
+    //% help=/input/rotation weight=52
+    //% blockId=device_get_rotation block="rotation (°)|%NAME" blockGap=8 icon="\uf197"
+    int rotation(Rotation kind) {
+      switch (kind) {
+      case Rotation::Pitch: return uBit.accelerometer.getPitch();
+      case Rotation::Roll: return uBit.accelerometer.getRoll();
+      }
+      return 0;        
+    }
+
+    /**
+     * Get the magnetic force value in ``micro-Teslas`` (``µT``). This function is not supported in the simulator.
+     * @param dimension TODO
+     */
+    //% help=input/magnetic-force weight=51
+    //% blockId=device_get_magnetic_force block="magnetic force (µT)|%NAME" blockGap=8 icon="\uf076"
+    int magneticForce(Dimension dimension) {
+      if (!uBit.compass.isCalibrated())
+        uBit.compass.calibrate();
+
+      switch (dimension) {
+      case Dimension::X: return uBit.compass.getX() / 1000;
+      case Dimension::Y: return uBit.compass.getY() / 1000;
+      case Dimension::Z: return uBit.compass.getZ() / 1000;
+      case Dimension::Strength: return uBit.compass.getFieldStrength() / 1000;
+      }
+      return 0;
+    }
+
+    /**
+     * Gets the number of milliseconds elapsed since power on.
+     */
+    //% help=input/running-time weight=50
+    //% blockId=device_get_running_time block="running time (ms)" icon="\uf017"
+    int runningTime() {
+        return uBit.systemTime();
+    }
+
+    /**
+     * Obsolete, compass calibration is automatic.
+     */
+    //% help=input/calibrate weight=0
+    void calibrate() { }
+
+    /**
+     * Get the pin state (pressed or not). Requires to hold the ground to close the circuit.
+     * @param name pin used to detect the touch
+     */
+    //% help=input/pin-is-pressed weight=58 block="pin|%NAME|is pressed" icon="\uf094"
+    bool pinIsPressed(TouchPin name) {
+        auto pin = getPin((int)name);
+        return pin && pin->isTouched();
+    }
+
+    /**
+     * Sets the accelerometer sample range in gravities.
+     * @param range a value describe the maximum strengh of acceleration measured
+     */
+    //% help=input/set-accelerator-range
+    //% blockId=device_set_accelerometer_range block="set accelerometer|range %range" icon="\uf135"
+    //% weight=5
+    void setAccelerometerRange(AcceleratorRange range) {
+        uBit.accelerometer.setRange((int)range);
+    }
+}

libs/microbit/input.ts

@@ -1,255 +1,5 @@
-enum Button {
-    //% enumval=MICROBIT_ID_BUTTON_A
-    A,
-    //% enumval=MICROBIT_ID_BUTTON_B
-    B,
-    //% enumval=MICROBIT_ID_BUTTON_AB
-    //% block="A+B"
-    AB,
-}
-
-enum Dimension {
-    //% block=x
-    X = 0,
-    //% block=y
-    Y = 1,
-    //% block=z
-    Z = 2,
-    //% block=strength
-    Strength = 3,
-}
-
-enum Rotation {
-    //% block=pitch
-    Pitch = 0,
-    //% block=roll
-    Roll = 1,
-}
-
-enum TouchPin {
-    //% enumval=uBit.io.P0
-    P0,
-    //% enumval=uBit.io.P1
-    P1,
-    //% enumval=uBit.io.P2
-    P2,
-}
-
-enum AcceleratorRange {
-    /**
-     * The accelerator measures forces up to 1 gravity
-     */
-    //%  block="1g"
-    OneG = 1,
-    /**
-     * The accelerator measures forces up to 2 gravity
-     */
-    //%  block="2g"
-    TwoG = 2,
-    /**
-     * The accelerator measures forces up to 4 gravity
-     */
-    //% block="4g"
-    FourG = 4,
-    /**
-     * The accelerator measures forces up to 8 gravity
-     */
-    //% block="8g"
-    EightG = 8
-}
-
-/*
-enum BasicGesture
-{
-    GESTURE_NONE,
-    GESTURE_UP,
-    GESTURE_DOWN,
-    GESTURE_LEFT,
-    GESTURE_RIGHT,
-    GESTURE_FACE_UP,
-    GESTURE_FACE_DOWN,
-    GESTURE_FREEFALL,
-    GESTURE_3G,
-    GESTURE_6G,
-    GESTURE_8G,
-    GESTURE_SHAKE
-};
-*/
-
-enum Gesture {
-    /**
-     * Raised when shaken
-     */
-    //% block=shake
-    Shake = 11,
-    /**
-     * Raised when the logo is upward and the screen is vertical
-     */
-    //% block="logo up"
-    LogoUp = 1,
-    /**
-     * Raised when the logo is downward and the screen is vertical
-     */
-    //% block="logo down"
-    LogoDown = 2,
-    /**
-     * Raised when the screen is pointing down and the board is horizontal
-     */
-    //% block="screen up"
-    ScreenUp = 5,
-    /**
-     * Raised when the screen is pointing up and the board is horizontal
-     */
-    //% block="screen down"
-    ScreenDown = 6,
-    /**
-     * Raised when the screen is pointing left
-     */
-    //% block="tilt left"
-    TiltLeft = 3,
-    /**
-     * Raised when the screen is pointing right
-     */
-    //% block="tilt right"
-    TiltRight = 4,    
-    /**
-     * Raised when the board is falling!
-     */
-    //% block="free fall"
-    FreeFall = 7
-}
-
 //% color=300 weight=99
 namespace input {
-    /**
-     * Do something when a button (``A``, ``B`` or both ``A+B``) is pressed
-     * @param button TODO
-     * @param body TODO
-     */
-    //% help=input/on-button-pressed weight=85
-    //% shim=micro_bit::onButtonPressed
-    //% blockId=device_button_event 
-    //% block="on button|%NAME|pressed" 
-    //% icon="\uf192"
-    export function onButtonPressed(button: Button, body: Action): void { }
-
-    /**
-     * Attaches code to run when the screen is facing up.
-     * @param body TODO
-     */
-    //% help=input/on-gesture shim=micro_bit::onGesture weight=84
-    //% blockId=device_gesture_event block="on |%NAME" icon="\uf135"
-    export function onGesture(gesture: Gesture, body: Action): void { }
-
-    /**
-     * Do something when a pin(``P0``, ``P1`` or both ``P2``) is pressed.
-     * @param name TODO
-     * @param body TODO
-     */
-    //% help=input/on-pin-pressed weight=83 shim=micro_bit::onPinPressed
-    //% blockId=device_pin_event block="on pin|%NAME|pressed" icon="\uf094"
-    export function onPinPressed(name: TouchPin, body: Action): void { }
-
-    /**
-     * Get the button state (pressed or not) for ``A`` and ``B``.
-     */
-    //% help=input/button-is-pressed weight=57
-    //% shim=micro_bit::isButtonPressed 
-    //% block="button|%NAME|is pressed"
-    //% blockId=device_get_button2
-    //% icon="\uf192" blockGap=8
-    export function buttonIsPressed(button: Button): boolean {
-        return false;
-    }
-
-
-    /**
-     * Get the current compass compass heading in degrees.
-     */
-    //% help=input/compass-heading 
-    //% weight=56 icon="\uf14e"
-    //% shim=micro_bit::compassHeading
-    //% blockId=device_heading block="compass heading (°)" blockGap=8
-    export function compassHeading(): number {
-        return 0;
-    }
-
-
-    /**
-     * Gets the temperature in Celsius degrees (°C).
-     */
-    //% weight=55 icon="\uf06d"
-    //% help=input/temperature shim=micro_bit::temperature
-    //% blockId=device_temperature block="temperature (°C)" blockGap=8
-    export function temperature(): number {
-        return 0;
-    }
-
-    /**
-     * Get the acceleration value in milli-gravitys (when the board is laying flat with the screen up, x=0, y=0 and z=-1024)
-     * @param dimension TODO
-     */
-    //% help=input/acceleration weight=54 icon="\uf135"
-    //% shim=micro_bit::getAcceleration
-    //% blockId=device_acceleration block="acceleration (mg)|%NAME" blockGap=8
-    export function acceleration(dimension: Dimension): number {
-        return 0;
-    }
-
-
-    /**
-     * Reads the light level applied to the LED screen in a range from ``0`` (dark) to ``255`` bright. In the simulator, the ``acceleration y`` is used to emulate this value.
-     */
-    //% help=input/light-level weight=53 shim=micro_bit::lightLevel
-    //% blockId=device_get_light_level block="light level" blockGap=8 icon="\uf185"
-    export function lightLevel(): number {
-        return 0;
-    }
-
-    /**
-     * The pitch of the device, rotation along the ``x-axis``, in degrees.
-     * @param kind TODO
-     */
-    //% help=/input/rotation weight=52 shim=micro_bit::getRotation
-    //% blockId=device_get_rotation block="rotation (°)|%NAME" blockGap=8 icon="\uf197"
-    export function rotation(kind: Rotation): number {
-        return 0;
-    }
-
-    /**
-     * Get the magnetic force value in ``micro-Teslas`` (``µT``). This function is not supported in the simulator.
-     * @param dimension TODO
-     */
-    //% help=input/magnetic-force weight=51 shim=micro_bit::getMagneticForce
-    //% blockId=device_get_magnetic_force block="magnetic force (µT)|%NAME" blockGap=8 icon="\uf076"
-    export function magneticForce(dimension: Dimension): number {
-        return 0;
-    }
-
-    /**
-     * Gets the number of milliseconds elapsed since power on.
-     */
-    //% help=input/running-time shim=micro_bit::getCurrentTime weight=50
-    //% blockId=device_get_running_time block="running time (ms)" icon="\uf017"
-    export function runningTime(): number {
-        return 0;
-    }
-
-    /**
-     * Obsolete, compass calibration is automatic.
-     */
-    //% help=input/calibrate weight=0 shim=TD_NOOP
-    export function calibrate(): void { }
-
-    /**
-     * Get the pin state (pressed or not). Requires to hold the ground to close the circuit.
-     * @param name pin used to detect the touch
-     */
-    //% help=input/pin-is-pressed weight=58 shim=micro_bit::isPinTouched block="pin|%NAME|is pressed" icon="\uf094"
-    export function pinIsPressed(name: TouchPin): boolean {
-        return false;
-    }
-
     /**
      * Attaches code to run when the screen is facing up.
      * @param body TODO
@@ -294,16 +44,4 @@ namespace input {
     export function onLogoDown(body: Action): void {
         onGesture(Gesture.LogoDown, body);
     }
-    
-    /**
-     * Sets the accelerometer sample range in gravities.
-     * @param range a value describe the maximum strengh of acceleration measured
-     */
-    //% help=input/set-accelerator-range
-    //% blockId=device_set_accelerometer_range block="set accelerometer|range %range" icon="\uf135"
-    //% weight=5
-    //% shim=micro_bit::setAccelerometerRange
-    export function setAccelerometerRange(range : AcceleratorRange) : void {
-        
-    }
 }

libs/microbit/kind.json

@@ -4,83 +4,34 @@
     "installedVersion": "tsmdvf",
     "files": [
         "README.md",
+        "dal.d.ts",
+        "enums.d.ts",
+        "shims.d.ts",
         "core.d.ts",
+        "ksbit.h",
+        "core.cpp",
         "mbit.ts",
-        "images.ts",
+        "images.cpp",
         "basic.cpp",
+        "input.cpp",
         "input.ts",
         "control.ts",
         "control.cpp",
         "game.ts",
+        "led.cpp",
         "led.ts",
         "music.ts",
+        "pins.cpp",
         "pins.ts",
-        "serial.ts"
+        "serial.cpp",
+        "serial.ts",
+        "buffer.cpp"
     ],
     "public": true,
     "dependencies": {},
-    "target": {
-        "id": "microbit",
-        "name": "BBC micro:bit",
-        "title": "JavaScript for BBC micro:bit",
-        "cloud": {
-            "workspace": false,
-            "packages": true
-        },
-        "blocksprj": {
-            "id": "blocksprj",
-            "config": {
-                "name": "{0} block",
-                "dependencies": {
-                    "microbit": "*",
-                    "microbit-radio": "*"
-                },
-                "description": "",
-                "files": [
-                    "main.blocks",
-                    "main.blocks.ts",
-                    "README.md"
-                ]
-            },
-            "files": {
-                "main.blocks": "<xml xmlns=\"http://www.w3.org/1999/xhtml\"><block type=\"device_print_message\"><value name=\"text\"><shadow type=\"text\"><field name=\"TEXT\">Hello!</field></shadow></value></block></xml>",
-                "main.blocks.ts": "\n",
-                "README.md": "Describe your project here!"
-            }
-        },
-        "tsprj": {
-            "id": "tsprj",
-            "config": {
-                "name": "{0} bit",
-                "dependencies": {
-                    "microbit": "*",
-                    "microbit-radio": "*"
-                },
-                "description": "",
-                "files": [
-                    "main.ts",
-                    "README.md"
-                ]
-            },
-            "files": {
-                "main.ts": "basic.showString('Hello!')\n",
-                "README.md": "Describe your project here!"
-            }
-        },
-        "compile": {
-            "isNative": false,
-            "hasHex": true
-        },
-        "simulator": {
-            "autoRun": true
-        },
-        "compileService": {
-            "gittag": "v0",
-            "serviceId": "ws"
-        },
-        "serial": {
-            "manufacturerFilter": "^mbed$",
-            "log": true
+    "microbit": {
+        "config": {
+            "MESSAGE_BUS_LISTENER_DEFAULT_FLAGS": "MESSAGE_BUS_LISTENER_QUEUE_IF_BUSY"
         }
     }
 }

libs/microbit/ksbit.h

@@ -0,0 +1,8 @@
+#include "kindscript.h"
+#include "ManagedBuffer.h"
+
+using namespace kindscript;
+MicroBitPin *getPin(int id);
+typedef ImageData* Image;
+typedef BufferData* Buffer;
+

libs/microbit/led.cpp

@@ -0,0 +1,104 @@
+#include "ksbit.h"
+
+enum class DisplayMode_ {
+    //% block="black and white"
+    BackAndWhite = DISPLAY_MODE_BLACK_AND_WHITE,
+    //% block="greyscale"
+    Greyscale = DISPLAY_MODE_GREYSCALE,
+    // TODO DISPLAY_MODE_BLACK_AND_WHITE_LIGHT_SENSE
+};
+
+//% color=3 weight=35
+namespace led {
+
+    /**
+     * Turn on the specified LED using x, y coordinates (x is horizontal, y is vertical). (0,0) is upper left.
+     * @param x TODO
+     * @param y TODO
+     */
+    //% help=led/plot weight=78
+    //% blockId=device_plot block="plot|x %x|y %y" icon="\uf205" blockGap=8
+    void plot(int x, int y) { 
+      uBit.display.image.setPixelValue(x, y, 1);
+    }
+
+    /**
+     * Turn off the specified LED using x, y coordinates (x is horizontal, y is vertical). (0,0) is upper left.
+     * @param x TODO
+     * @param y TODO
+     */
+    //% help=led/unplot weight=77
+    //% blockId=device_unplot block="unplot|x %x|y %y" icon="\uf204" blockGap=8
+    void unplot(int x, int y) { 
+      uBit.display.image.setPixelValue(x, y, 0);
+    }
+
+    /**
+     * Get the on/off state of the specified LED using x, y coordinates. (0,0) is upper left.
+     * @param x TODO
+     * @param y TODO
+     */
+    //% help=led/point weight=76
+    //% blockId=device_point block="point|x %x|y %y" icon="\uf10c"
+    bool point(int x, int y) {
+      int pix = uBit.display.image.getPixelValue(x, y);
+      return pix > 0;
+    }
+
+    /**
+     * Get the screen brightness from 0 (off) to 255 (full bright).
+     */
+    //% help=led/brightness weight=60
+    //% blockId=device_get_brightness block="brightness" icon="\uf042" blockGap=8
+    int brightness() {
+      return uBit.display.getBrightness();
+    }
+
+    /**
+     * Set the screen brightness from 0 (off) to 255 (full bright).
+     * @param value the brightness value, eg:255, 127, 0
+     */
+    //% help=led/set-brightness weight=59
+    //% blockId=device_set_brightness block="set brightness %value" icon="\uf042"
+    void setBrightness(int value) { 
+       uBit.display.setBrightness(value);
+    }
+
+    /**
+     * Cancels the current animation and clears other pending animations.
+     */
+    //% weight=50 help=led/stop-animation
+    //% blockId=device_stop_animation block="stop animation" icon="\uf04d"
+    void stopAnimation() { 
+       uBit.display.stopAnimation();
+    }
+
+    /**
+     * Sets the display mode between black and white and greyscale for rendering LEDs.
+     * @param mode TODO
+     */
+    //% weight=1 help=/led/set-display-mode
+    void setDisplayMode(DisplayMode_ mode) { 
+        uBit.display.setDisplayMode((DisplayMode)mode);
+    }
+
+    /**
+     * Takes a screenshot of the LED screen and returns an image.
+     */
+    //% help=led/screenshot
+    Image screenshot() {
+      return uBit.display.screenShot().leakData();
+        /*
+        let Image img;
+        img = image.createImage("");
+        for (let i = 0; i < 5; i++) {
+            for (let j = 0; j < 5; j++) {
+                if (led.point(i, j)) {
+                    img.setPixel(i, j, true);
+                }
+            }
+        }
+        return img;
+        */
+    }
+}

libs/microbit/led.ts

@@ -1,64 +1,5 @@
-enum DisplayMode {
-    //% block="black and white"
-    BackAndWhite = 0,
-    //% block="greyscale"
-    Greyscale = 1,
-}
-
 //% color=3 weight=35
 namespace led {
-    /**
-     * Turn on the specified LED using x, y coordinates (x is horizontal, y is vertical). (0,0) is upper left.
-     * @param x TODO
-     * @param y TODO
-     */
-    //% help=led/plot weight=78 shim=micro_bit::plot
-    //% blockId=device_plot block="plot|x %x|y %y" icon="\uf205" blockGap=8
-    export function plot(x: number, y: number): void { }
-
-    /**
-     * Turn off the specified LED using x, y coordinates (x is horizontal, y is vertical). (0,0) is upper left.
-     * @param x TODO
-     * @param y TODO
-     */
-    //% help=led/unplot weight=77 shim=micro_bit::unPlot
-    //% blockId=device_unplot block="unplot|x %x|y %y" icon="\uf204" blockGap=8
-    export function unplot(x: number, y: number): void { }
-
-    /**
-     * Get the on/off state of the specified LED using x, y coordinates. (0,0) is upper left.
-     * @param x TODO
-     * @param y TODO
-     */
-    //% help=led/point weight=76 shim=micro_bit::point
-    //% blockId=device_point block="point|x %x|y %y" icon="\uf10c"
-    export function point(x: number, y: number): boolean {
-        return false;
-    }
-
-    /**
-     * Get the screen brightness from 0 (off) to 255 (full bright).
-     */
-    //% help=led/brightness weight=60 shim=micro_bit::getBrightness
-    //% blockId=device_get_brightness block="brightness" icon="\uf042" blockGap=8
-    export function brightness(): number {
-        return 0;
-    }
-
-    /**
-     * Set the screen brightness from 0 (off) to 255 (full bright).
-     * @param value the brightness value, eg:255, 127, 0
-     */
-    //% help=led/set-brightness weight=59 shim=micro_bit::setBrightness
-    //% blockId=device_set_brightness block="set brightness %value" icon="\uf042"
-    export function setBrightness(value: number): void { }
-
-    /**
-     * Cancels the current animation and clears other pending animations.
-     */
-    //% weight=50 shim=uBit.display.stopAnimation help=led/stop-animation
-    //% blockId=device_stop_animation block="stop animation" icon="\uf04d"
-    export function stopAnimation(): void { }
 
     /**
      * Displays a vertical bar graph based on the ``value`` and ``high`` value.
@@ -69,7 +10,7 @@ namespace led {
     //% blockId=device_plot_bar_graph block="plot bar graph of %value |up to %high" icon="\uf080" blockExternalInputs=true
     export function plotBarGraph(value: number, high: number): void {
         
-        writeString(value.toString() + "\r\n");
+        serial.writeString(value.toString() + "\r\n");
         
         let v = Math.abs((value * 15) / high);
         let k = 0;
@@ -87,19 +28,6 @@ namespace led {
         }        
     }
     
-    /**
-     * Writes a string to serial
-     */
-    //% shim=micro_bit::serialSendString
-    function writeString(text: string): void { }
-
-    /**
-     * Sets the display mode between black and white and greyscale for rendering LEDs.
-     * @param mode TODO
-     */
-    //% shim=micro_bit::setDisplayMode weight=1 help=/led/set-display-mode
-    export function setDisplayMode(mode: DisplayMode): void { }
-
     /**
      * Toggles a particular pixel
      * @param x TODO
@@ -182,25 +110,5 @@ namespace led {
         led.setBrightness(0);
     }
 
-    /**
-     * Takes a screenshot of the LED screen and returns an image.
-     */
-    //% shim=uBit.display.screenShot help=led/screenshot
-    export function screenshot(): images.Image {
-        /*
-        let img: Image;
-        img = image.createImage("");
-        for (let i = 0; i < 5; i++) {
-            for (let j = 0; j < 5; j++) {
-                if (led.point(i, j)) {
-                    img.setPixel(i, j, true);
-                }
-            }
-        }
-        return img;
-        */
-        return null;
-    }
-
 
 }

libs/microbit/mbit.ts

@@ -13,16 +13,52 @@ namespace helpers {
 
 namespace console {
     export function log(msg: string) {
-        writeString(msg);
-        writeString("\r\n");
+        serial.writeString(msg);
+        serial.writeString("\r\n");
     }
-    
-    //% shim=micro_bit::serialSendString
-    function writeString(text: string): void { }
 }
 
-namespace math {
+namespace Math {
     export function clamp(min: number, max:number, value:number): number {
         return Math.min(max, Math.max(min, value));
     }
+
+    /**
+      * Returns the absolute value of a number (the value without regard to whether it is positive or negative). 
+      * For example, the absolute value of -5 is the same as the absolute value of 5.
+      * @param x A numeric expression for which the absolute value is needed.
+      */
+    export function abs(x: number): number
+    {
+        return x < 0 ? -x : x;
+    }
+    
+    /**
+      * Returns the sign of the x, indicating whether x is positive, negative or zero.
+      * @param x The numeric expression to test
+      */
+    export function sign(x: number): number
+    {
+        if (x == 0) return 0;
+        if (x > 0) return 1;
+        return -1;
+    }
+    
+    /**
+      * Returns the larger of two supplied numeric expressions. 
+      */
+    export function max(a:number, b:number): number
+    {
+        if (a >= b) return a;
+        return b;
+    }
+    
+    /**
+      * Returns the smaller of two supplied numeric expressions. 
+      */
+    export function min(a:number, b:number): number
+    {
+        if (a <= b) return a;
+        return b;
+    }
 }

libs/microbit/music.ts

@@ -116,7 +116,7 @@ namespace music {
      * Gets the frequency of a note.
      * @param name TODO
      */
-    //% shim=TD_ID weight=50 help=music/note-frequency
+    //% weight=50 help=music/note-frequency
     //% blockId=device_note block="%note"
     export function noteFrequency(name: Note): number {
         return name;

libs/microbit/pins.cpp

@@ -0,0 +1,218 @@
+#include "ksbit.h"
+
+enum class DigitalPin {
+    P0 = MICROBIT_ID_IO_P0,
+    P1 = MICROBIT_ID_IO_P1,
+    P2 = MICROBIT_ID_IO_P2,
+    P3 = MICROBIT_ID_IO_P3,
+    P4 = MICROBIT_ID_IO_P4,
+    P5 = MICROBIT_ID_IO_P5,
+    P6 = MICROBIT_ID_IO_P6,
+    P7 = MICROBIT_ID_IO_P7,
+    P8 = MICROBIT_ID_IO_P8,
+    P9 = MICROBIT_ID_IO_P9,
+    P10 = MICROBIT_ID_IO_P10,
+    P11 = MICROBIT_ID_IO_P11,
+    P12 = MICROBIT_ID_IO_P12,
+    P13 = MICROBIT_ID_IO_P13,
+    P14 = MICROBIT_ID_IO_P14,
+    P15 = MICROBIT_ID_IO_P15,
+    P16 = MICROBIT_ID_IO_P16,
+    P19 = MICROBIT_ID_IO_P19,
+    P20 = MICROBIT_ID_IO_P20,
+};
+
+enum class AnalogPin {
+    P0 = MICROBIT_ID_IO_P0,
+    P1 = MICROBIT_ID_IO_P1,
+    P2 = MICROBIT_ID_IO_P2,
+    P3 = MICROBIT_ID_IO_P3,
+    P4 = MICROBIT_ID_IO_P4,
+    P10 = MICROBIT_ID_IO_P10,
+};
+
+MicroBitPin *getPin(int id) {
+    switch (id) {
+        case MICROBIT_ID_IO_P0: return &uBit.io.P0;
+        case MICROBIT_ID_IO_P1: return &uBit.io.P1;
+        case MICROBIT_ID_IO_P2: return &uBit.io.P2;
+        case MICROBIT_ID_IO_P3: return &uBit.io.P3;
+        case MICROBIT_ID_IO_P4: return &uBit.io.P4;
+        case MICROBIT_ID_IO_P5: return &uBit.io.P5;
+        case MICROBIT_ID_IO_P6: return &uBit.io.P6;
+        case MICROBIT_ID_IO_P7: return &uBit.io.P7;
+        case MICROBIT_ID_IO_P8: return &uBit.io.P8;
+        case MICROBIT_ID_IO_P9: return &uBit.io.P9;
+        case MICROBIT_ID_IO_P10: return &uBit.io.P10;
+        case MICROBIT_ID_IO_P11: return &uBit.io.P11;
+        case MICROBIT_ID_IO_P12: return &uBit.io.P12;
+        case MICROBIT_ID_IO_P13: return &uBit.io.P13;
+        case MICROBIT_ID_IO_P14: return &uBit.io.P14;
+        case MICROBIT_ID_IO_P15: return &uBit.io.P15;
+        case MICROBIT_ID_IO_P16: return &uBit.io.P16;
+        case MICROBIT_ID_IO_P19: return &uBit.io.P19;
+        case MICROBIT_ID_IO_P20: return &uBit.io.P20;
+        default: return NULL;
+    }
+}
+
+
+//% color=351 weight=30
+namespace pins {
+    #define PINOP(op) \
+      MicroBitPin *pin = getPin((int)name); \
+      if (!pin) return; \
+      pin->op
+
+    #define PINREAD(op) \
+      MicroBitPin *pin = getPin((int)name); \
+      if (!pin) return 0; \
+      return pin->op
+
+
+    //%
+    MicroBitPin *getPinAddress(int id) {
+        return getPin(id);
+    }
+
+
+    /**
+     * Read the specified pin or connector as either 0 or 1
+     * @param name pin to read from
+     */
+    //% help=pins/digital-read-pin weight=30
+    //% blockId=device_get_digital_pin block="digital read|pin %name" blockGap=8
+    int digitalReadPin(DigitalPin name) {
+        PINREAD(getDigitalValue());
+    }
+
+    /**
+      * Set a pin or connector value to either 0 or 1.
+      * @param name pin to write to
+      * @param value value to set on the pin, 1 eg,0
+      */
+    //% help=pins/digital-write-pin weight=29
+    //% blockId=device_set_digital_pin block="digital write|pin %name|to %value"
+    void digitalWritePin(DigitalPin name, int value) { 
+        PINOP(setDigitalValue(value));
+    }
+
+    /**
+     * Read the connector value as analog, that is, as a value comprised between 0 and 1023.
+     * @param name pin to write to
+     */
+    //% help=pins/analog-read-pin weight=25
+    //% blockId=device_get_analog_pin block="analog read|pin %name" blockGap="8" 
+    int analogReadPin(AnalogPin name) {
+        PINREAD(getAnalogValue());
+    }
+
+    /**
+     * Set the connector value as analog. Value must be comprised between 0 and 1023.
+     * @param name pin name to write to
+     * @param value value to write to the pin between ``0`` and ``1023``. eg:1023,0
+     */
+    //% help=pins/analog-write-pin weight=24
+    //% blockId=device_set_analog_pin block="analog write|pin %name|to %value" blockGap=8
+    void analogWritePin(AnalogPin name, int value) { 
+        PINOP(setAnalogValue(value));
+    }
+
+    /**
+     * Configures the Pulse-width modulation (PWM) of the analog output to the given value in **microseconds** or `1/1000` milliseconds.
+     * If this pin is not configured as an analog output (using `analog write pin`), the operation has no effect.
+     * @param name analog pin to set period to
+     * @param micros period in micro seconds. eg:20000
+     */
+    //% help=pins/analog-set-period weight=23
+    //% blockId=device_set_analog_period block="analog set period|pin %pin|to (µs)%micros" 
+    void analogSetPeriod(AnalogPin name, int micros) { 
+        PINOP(setAnalogPeriodUs(micros));
+    }
+
+    /**
+     * Writes a value to the servo, controlling the shaft accordingly. On a standard servo, this will set the angle of the shaft (in degrees), moving the shaft to that orientation. On a continuous rotation servo, this will set the speed of the servo (with ``0`` being full-speed in one direction, ``180`` being full speed in the other, and a value near ``90`` being no movement).
+     * @param name pin to write to
+     * @param value angle or rotation speed, eg:180,90,0
+     */
+    //% help=pins/servo-write-pin weight=20
+    //% blockId=device_set_servo_pin block="servo write|pin %name|to %value" blockGap=8
+    void servoWritePin(AnalogPin name, int value) { 
+        PINOP(setServoValue(value));
+    }
+
+    /**
+     * Configures this IO pin as an analog/pwm output, configures the period to be 20 ms, and sets the pulse width, based on the value it is given **microseconds** or `1/1000` milliseconds.
+     * @param name pin name
+     * @param micros pulse duration in micro seconds, eg:1500
+     */
+    //% help=pins/serial-set-pulse weight=19
+    //% blockId=device_set_servo_pulse block="servo set pulse|pin %value|to (µs) %micros"
+    void servoSetPulse(AnalogPin name, int micros) { 
+        PINOP(setServoPulseUs(micros));
+    }
+
+
+    MicroBitPin* pitchPin = NULL;
+
+    /**
+     * Sets the pin used when using `pins->analog pitch`.
+     * @param name TODO
+     */
+    //% help=pins/analog-set-pitch weight=12
+    void analogSetPitchPin(AnalogPin name) { 
+      pitchPin = getPin((int)name);
+    }
+
+    /**
+     * Emits a Pulse-width modulation (PWM) signal to the current pitch pin. Use `analog set pitch pin` to define the pitch pin.
+     * @param frequency TODO
+     * @param ms TODO
+     */
+    //% help=pins/analog-pitch weight=14 async
+    void analogPitch(int frequency, int ms) { 
+      if (pitchPin == NULL) return;
+      if (frequency <= 0) {
+        pitchPin->setAnalogValue(0);
+      } else {
+        pitchPin->setAnalogValue(512);
+        pitchPin->setAnalogPeriodUs(1000000/frequency);
+      }
+      
+      if (ms > 0) {
+          uBit.sleep(ms);
+          pitchPin->setAnalogValue(0);
+          wait_ms(5);
+      }
+    }
+
+    /**
+     * Create a new zero-initialized buffer.
+     * @param size number of bytes in the buffer
+     */
+    //%
+    Buffer createBuffer(int size)
+    {
+        return ManagedBuffer(size).leakData();
+    }
+
+    /**
+     * Read `size` bytes from a 7-bit I2C `address`.
+     */
+    //% repeat.defl=0
+    Buffer i2cReadBuffer(int address, int size, bool repeat)
+    {
+      Buffer buf = createBuffer(size);
+      uBit.i2c.read(address << 1, (char*)buf->payload, size, repeat);
+      return buf;
+    }
+    
+    /**
+     * Write bytes to a 7-bit I2C `address`.
+     */
+    //% repeat.defl=0
+    void i2cWriteBuffer(int address, Buffer buf, bool repeat)
+    {
+      uBit.i2c.write(address << 1, (char*)buf->payload, buf->length, repeat);
+    }
+}

libs/microbit/pins.ts

@@ -1,129 +1,5 @@
-enum DigitalPin {
-    //% enumval=uBit.io.P0
-    P0,
-    //% enumval=uBit.io.P1
-    P1,
-    //% enumval=uBit.io.P2
-    P2,
-    //% enumval=uBit.io.P3
-    P3,
-    //% enumval=uBit.io.P4
-    P4,
-    //% enumval=uBit.io.P5
-    P5,
-    //% enumval=uBit.io.P6
-    P6,
-    //% enumval=uBit.io.P7
-    P7,
-    //% enumval=uBit.io.P8
-    P8,
-    //% enumval=uBit.io.P9
-    P9,
-    //% enumval=uBit.io.P10
-    P10,
-    //% enumval=uBit.io.P11
-    P11,
-    //% enumval=uBit.io.P12
-    P12,
-    //% enumval=uBit.io.P13
-    P13,
-    //% enumval=uBit.io.P14
-    P14,
-    //% enumval=uBit.io.P15
-    P15,
-    //% enumval=uBit.io.P16
-    P16,
-    //% enumval=uBit.io.P19
-    P19,
-    //% enumval=uBit.io.P20
-    P20,
-}
-
-enum AnalogPin {
-    //% enumval=uBit.io.P0
-    P0,
-    //% enumval=uBit.io.P1
-    P1,
-    //% enumval=uBit.io.P2
-    P2,
-    //% enumval=uBit.io.P3
-    P3,
-    //% enumval=uBit.io.P4
-    P4,
-    //% enumval=uBit.io.P10
-    P10,
-}
-
-
 //% color=351 weight=30
 namespace pins {
-    /**
-     * Read the specified pin or connector as either 0 or 1
-     * @param name pin to read from
-     */
-    //% help=pins/digital-read-pin weight=30 shim=micro_bit::digitalReadPin
-    //% blockId=device_get_digital_pin block="digital read|pin %name" blockGap=8
-    export function digitalReadPin(name: DigitalPin): number {
-        
-        return 0;
-    }
-
-    /**
-      * Set a pin or connector value to either 0 or 1.
-      * @param name pin to write to
-      * @param value value to set on the pin, eg: 1,0
-      */
-    //% help=pins/digital-write-pin weight=29 shim=micro_bit::digitalWritePin
-    //% blockId=device_set_digital_pin block="digital write|pin %name|to %value"
-    export function digitalWritePin(name: DigitalPin, value: number): void { }
-
-    /**
-     * Read the connector value as analog, that is, as a value comprised between 0 and 1023.
-     * @param name pin to write to
-     */
-    //% help=pins/analog-read-pin weight=25 shim=micro_bit::analogReadPin
-    //% blockId=device_get_analog_pin block="analog read|pin %name" blockGap="8" 
-    export function analogReadPin(name: AnalogPin): number {
-        return 0;
-    }
-
-    /**
-     * Set the connector value as analog. Value must be comprised between 0 and 1023.
-     * @param name pin name to write to
-     * @param value value to write to the pin between ``0`` and ``1023``. eg:1023,0
-     */
-    //% help=pins/analog-write-pin weight=24 shim=micro_bit::analogWritePin
-    //% blockId=device_set_analog_pin block="analog write|pin %name|to %value" blockGap=8
-    export function analogWritePin(name: AnalogPin, value: number): void { }
-
-    /**
-     * Configures the Pulse-width modulation (PWM) of the analog output to the given value in **microseconds** or `1/1000` milliseconds.
-     * If this pin is not configured as an analog output (using `analog write pin`), the operation has no effect.
-     * @param pin analog pin to set period to
-     * @param micros period in micro seconds. eg:20000
-     */
-    //% shim=micro_bit::setAnalogPeriodUs help=pins/analog-set-period weight=23
-    //% blockId=device_set_analog_period block="analog set period|pin %pin|to (µs)%micros" 
-    export function analogSetPeriod(pin: AnalogPin, micros: number): void { }
-
-    /**
-     * Writes a value to the servo, controlling the shaft accordingly. On a standard servo, this will set the angle of the shaft (in degrees), moving the shaft to that orientation. On a continuous rotation servo, this will set the speed of the servo (with ``0`` being full-speed in one direction, ``180`` being full speed in the other, and a value near ``90`` being no movement).
-     * @param name pin to write to
-     * @param value angle or rotation speed, eg:180,90,0
-     */
-    //% help=pins/servo-write-pin weight=20 shim=micro_bit::servoWritePin
-    //% blockId=device_set_servo_pin block="servo write|pin %name|to %value" blockGap=8
-    export function servoWritePin(name: AnalogPin, value: number): void { }
-
-    /**
-     * Configures this IO pin as an analog/pwm output, configures the period to be 20 ms, and sets the pulse width, based on the value it is given **microseconds** or `1/1000` milliseconds.
-     * @param pin pin name
-     * @param micros pulse duration in micro seconds, eg:1500
-     */
-    //% shim=micro_bit::setServoPulseUs help=pins/serial-set-pulse weight=19
-    //% blockId=device_set_servo_pulse block="servo set pulse|pin %value|to (µs) %micros"
-    export function servoSetPulse(pin: AnalogPin, micros: number): void { }
-
     /**
      * Re-maps a number from one range to another. That is, a value of ``from low`` would get mapped to ``to low``, a value of ``from high`` to ``to high``, values in-between to values in-between, etc.
      * @param value value to map in ranges
@@ -139,17 +15,41 @@ namespace pins {
     }
 
     /**
-     * Sets the pin used when using `pins->analog pitch`.
-     * @param name TODO
+     * Read one number from 7-bit I2C address.
      */
-    //% shim=micro_bit::enablePitch help=pins/analog-set-pitch weight=12
-    export function analogSetPitchPin(name: AnalogPin): void { }
+    export function i2cReadNumber(address: number, format: NumberFormat): number {
+        let buf = pins.i2cReadBuffer(address, pins.sizeOf(format), false)
+        return buf.getNumber(format, 0)
+    }
 
     /**
-     * Emits a Pulse-width modulation (PWM) signal to the current pitch pin. Use `analog set pitch pin` to define the pitch pin.
-     * @param frequency TODO
-     * @param ms TODO
+     * Write one number to a 7-bit I2C address.
      */
-    //% shim=micro_bit::pitch help=pins/analog-pitch weight=14 async
-    export function analogPitch(frequency: number, ms: number): void { }
+    export function i2cWriteNumber(address: number, value: number, format: NumberFormat): void {
+        let buf = createBuffer(pins.sizeOf(format))
+        buf.setNumber(format, 0, value)
+        pins.i2cWriteBuffer(address, buf, false)
+    }
+
+    /**
+     * Get the size in bytes of specified number format.
+     */
+    export function sizeOf(format: NumberFormat) {
+        switch (format) {
+            case NumberFormat.Int8LE:
+            case NumberFormat.UInt8LE:
+            case NumberFormat.Int8BE:
+            case NumberFormat.UInt8BE:
+                return 1;
+            case NumberFormat.Int16LE:
+            case NumberFormat.UInt16LE:
+            case NumberFormat.Int16BE:
+            case NumberFormat.UInt16BE:
+                return 2;
+            case NumberFormat.Int32LE:
+            case NumberFormat.Int32BE:
+                return 4;
+        }
+        return 0;
+    }
 }

libs/microbit/serial.cpp

@@ -0,0 +1,38 @@
+#include "ksbit.h"
+
+//% weight=2 color=30
+namespace serial {
+    // note that at least one // followed by % is needed per declaration!
+    
+    /**
+     * Reads a line of text from the serial port.
+     */
+    //%
+    StringData* readString() {
+      return uBit.serial.readString().leakData();
+    }
+
+    /**
+     * Sends a piece of text through Serial connection.
+     */
+    //%
+    void writeString(StringData *text) { 
+      uBit.serial.sendString(ManagedString(text));
+    }
+
+    /**
+     * Sends the current pixel values, byte-per-pixel, over serial.
+     */
+    //%
+    void writeScreen() {
+        uBit.serial.sendDisplayState(); 
+    }
+
+    /**
+     * Reads the screen from serial.
+     */
+    //%
+    void readScreen() { 
+        uBit.serial.readDisplayState();
+    }
+}

libs/microbit/serial.ts

@@ -17,32 +17,6 @@ namespace serial {
         writeString(value.toString());
     }
 
-    /**
-     * Reads a line of text from the serial port.
-     */
-    //% shim=micro_bit::serialReadString
-    export function readString(): string {
-        return ""
-    }
-
-    /**
-     * Sends a piece of text through Serial connection.
-     */
-    //% shim=micro_bit::serialSendString
-    export function writeString(text: string): void { }
-
-    /**
-     * Sends the current pixel values, byte-per-pixel, over serial.
-     */
-    //% shim=micro_bit::serialSendDisplayState
-    export function writeScreen(): void { }
-
-    /**
-     * Reads the screen from serial.
-     */
-    //% shim=micro_bit::serialReadDisplayState
-    export function readScreen(): void { }
-
     /**
      * Writes a ``name: value`` pair line to the serial.
      * @param name name of the value stream, eg: x

libs/microbit/shims.d.ts

@@ -0,0 +1,641 @@
+// Auto-generated. Do not edit.
+
+
+declare interface String {
+    /**
+     * Returns the character at the specified index.
+     * @param pos The zero-based index of the desired character.
+     */
+    //% shim=StringMethods::charAt
+    charAt(pos: number): string;
+
+    /** 
+     * Returns the Unicode value of the character at the specified location.
+     * @param index The zero-based index of the desired character. If there is no character at the specified index, NaN is returned.
+     */
+    //% shim=StringMethods::charCodeAt
+    charCodeAt(index: number): number;
+
+    /**
+     * Returns a string that contains the concatenation of two or more strings.
+     * @param other The string to append to the end of the string.  
+     */
+    //% shim=StringMethods::concat
+    concat(other: string): string;
+
+    /**
+     * Determines whether relative order of two strings (in ASCII encoding).
+     * @param that String to compare to target string
+     */
+    //% shim=StringMethods::compare
+    compare(that: string): number;
+
+    /** Returns the length of a String object. */
+    //% property shim=StringMethods::length
+    length: number;
+}
+
+
+declare interface Boolean {
+    /**
+     * Returns a string representation of an object.
+     */
+    //% shim=BooleanMethods::toString
+    toString(): string;
+}
+declare namespace String {
+
+    /**
+     * Make a string from the given ASCII character code. 
+     */
+    //% shim=String_::fromCharCode
+    function fromCharCode(code: number): string;
+}
+
+
+declare interface Number {
+    /**
+     * Returns a string representation of a number.
+     */
+    //% shim=NumberMethods::toString
+    toString(): string;
+}
+declare namespace Math {
+
+    /**
+     * Returns the value of a base expression taken to a specified power. 
+     * @param x The base value of the expression.
+     * @param y The exponent value of the expression.
+     */
+    //% shim=Math_::pow
+    function pow(x: number, y: number): number;
+
+    /** 
+     * Returns a pseudorandom number between 0 and `max`. 
+     */
+    //% shim=Math_::random
+    function random(max: number): number;
+
+    /**
+     * Returns the square root of a number.
+     * @param x A numeric expression.
+     */
+    //% shim=Math_::sqrt
+    function sqrt(x: number): number;
+}
+
+
+
+    //% color=45 weight=31
+declare namespace images {
+
+    /**
+     * Creates an image that fits on the LED screen.
+     */
+    //% weight=75 help=images/create-image
+    //% blockId=device_build_image block="create image" imageLiteral=1 shim=images::createImage
+    function createImage(leds: string): Image;
+
+    /**
+     * Creates an image with 2 frames.
+     */
+    //% weight=74 help=images/create-big-image
+    //% blockId=device_build_big_image block="create big image" imageLiteral=2 shim=images::createBigImage
+    function createBigImage(leds: string): Image;
+}
+
+
+declare interface Image {
+    /**
+     * Shows an frame from the image at offset ``x offset``.
+     * @param xOffset TODO
+     */
+    //% help=images/show-image weight=80 async
+    //% BUGblockId=device_show_image_offset block="show image %sprite|at offset %offset" blockGap=8 xOffset.defl=0 shim=ImageMethods::showImage
+    showImage(xOffset?: number): void;
+
+    /**
+     * Scrolls an image .
+     * @param frameOffset x offset moved on each animation step, eg: 5, 1, -1
+     * @param interval time between each animation step in milli seconds, eg: 200
+     */
+    //% help=images/show-image weight=79 async
+    //% BUGblockId=device_scroll_image block="scroll image %sprite|with offset %frameoffset|and interval (ms) %delay" blockGap=8 frameOffset.defl=0 interval.defl=200 shim=ImageMethods::scrollImage
+    scrollImage(frameOffset?: number, interval?: number): void;
+
+    /**
+     * Plots the image at a given column to the screen
+     */
+    //% help=images/plot-image xOffset.defl=0 shim=ImageMethods::plotImage
+    plotImage(xOffset?: number): void;
+
+    /**
+     * Sets all pixels off.
+     */
+    //% help=images/clear shim=ImageMethods::clear
+    clear(): void;
+
+    /**
+     * Sets a specific pixel brightness at a given position
+     */
+    //% help= shim=ImageMethods::setPixelBrightness
+    setPixelBrightness(x: number, y: number, value: number): void;
+
+    /**
+     * Gets the pixel brightness ([0..255]) at a given position
+     */
+    //% help= shim=ImageMethods::pixelBrightness
+    pixelBrightness(x: number, y: number): number;
+}
+
+
+    /**
+     * Provides access to basic micro:bit functionality.
+     */
+    //% color=190 weight=100
+declare namespace basic {
+
+    /**
+     * Scroll a number on the screen. If the number fits on the screen (i.e. is a single digit), do not scroll.
+     * @param interval speed of scroll; eg: 150, 100, 200, -100
+     */
+    //% help=basic/show-number
+    //% weight=96
+    //% blockId=device_show_number block="show|number %number" blockGap=8 icon="\uf1ec"
+    //% async interval.defl=150 shim=basic::showNumber
+    function showNumber(value: number, interval?: number): void;
+
+    /**
+     * Draws an image on the LED screen.
+     * @param leds TODO
+     * @param interval TODO
+     */
+    //% help=basic/show-leds 
+    //% weight=95 blockGap=8
+    //% imageLiteral=1 async
+    //% blockId=device_show_leds
+    //% block="show leds" icon="\uf00a" interval.defl=400 shim=basic::showLeds
+    function showLeds(leds: string, interval?: number): void;
+
+    /**
+     * Display text on the display, one character at a time. If the string fits on the screen (i.e. is one letter), does not scroll.
+     * @param text the text to scroll on the screen, eg: "Hello!"
+     * @param interval how fast to shift characters; eg: 150, 100, 200, -100
+     */
+    //% help=basic/show-string 
+    //% weight=87 blockGap=8
+    //% block="show|string %text" icon="\uf031" 
+    //% async
+    //% blockId=device_print_message interval.defl=150 shim=basic::showString
+    function showString(text: string, interval?: number): void;
+
+    /**
+     * Turn off all LEDs
+     */
+    //% help=basic/clear-screen weight=79
+    //% blockId=device_clear_display block="clear screen" icon="\uf12d" shim=basic::clearScreen
+    function clearScreen(): void;
+
+    /**
+     * Shows a sequence of LED screens as an animation.
+     * @param leds TODO
+     * @param interval TODO
+     */
+    //% help=basic/show-animation imageLiteral=1 async interval.defl=400 shim=basic::showAnimation
+    function showAnimation(leds: string, interval?: number): void;
+
+    /**
+     * Draws an image on the LED screen.
+     * @param leds TODO
+     */
+    //% help=basic/plot-leds weight=80 imageLiteral=1 shim=basic::plotLeds
+    function plotLeds(leds: string): void;
+
+    /**
+     * Repeats the code forever in the background. On each iteration, allows other codes to run.
+     * @param body TODO
+     */
+    //% help=basic/forever weight=55 blockGap=8
+    //% blockId=device_forever block="forever" icon="\uf01e" shim=basic::forever
+    function forever(a: () => void): void;
+
+    /**
+     * Pause for the specified time in milliseconds
+     * @param ms how long to pause for, eg: 100, 200, 500, 1000, 2000
+     */
+    //% help=basic/pause weight=54
+    //% async block="pause (ms) %pause"
+    //% blockId=device_pause icon="\uf110" shim=basic::pause
+    function pause(ms: number): void;
+}
+
+
+
+    //% color=300 weight=99
+declare namespace input {
+
+    /**
+     * Do something when a button (``A``, ``B`` or both ``A+B``) is pressed
+     * @param button TODO
+     * @param body TODO
+     */
+    //% help=input/on-button-pressed weight=85
+    //% blockId=device_button_event 
+    //% block="on button|%NAME|pressed" 
+    //% icon="\uf192" shim=input::onButtonPressed
+    function onButtonPressed(button: Button, body: () => void): void;
+
+    /**
+     * Attaches code to run when the screen is facing up.
+     * @param body TODO
+     */
+    //% help=input/on-gesture weight=84
+    //% blockId=device_gesture_event block="on |%NAME" icon="\uf135" shim=input::onGesture
+    function onGesture(gesture: Gesture, body: () => void): void;
+
+    /**
+     * Do something when a pin(``P0``, ``P1`` or both ``P2``) is pressed.
+     * @param name TODO
+     * @param body TODO
+     */
+    //% help=input/on-pin-pressed weight=83
+    //% blockId=device_pin_event block="on pin|%NAME|pressed" icon="\uf094" shim=input::onPinPressed
+    function onPinPressed(name: TouchPin, body: () => void): void;
+
+    /**
+     * Get the button state (pressed or not) for ``A`` and ``B``.
+     */
+    //% help=input/button-is-pressed weight=57
+    //% block="button|%NAME|is pressed"
+    //% blockId=device_get_button2
+    //% icon="\uf192" blockGap=8 shim=input::buttonIsPressed
+    function buttonIsPressed(button: Button): boolean;
+
+    /**
+     * Get the current compass compass heading in degrees.
+     */
+    //% help=input/compass-heading 
+    //% weight=56 icon="\uf14e"
+    //% blockId=device_heading block="compass heading (°)" blockGap=8 shim=input::compassHeading
+    function compassHeading(): number;
+
+    /**
+     * Gets the temperature in Celsius degrees (°C).
+     */
+    //% weight=55 icon="\uf06d"
+    //% help=input/temperature
+    //% blockId=device_temperature block="temperature (°C)" blockGap=8 shim=input::temperature
+    function temperature(): number;
+
+    /**
+     * Get the acceleration value in milli-gravitys (when the board is laying flat with the screen up, x=0, y=0 and z=-1024)
+     * @param dimension TODO
+     */
+    //% help=input/acceleration weight=54 icon="\uf135"
+    //% blockId=device_acceleration block="acceleration (mg)|%NAME" blockGap=8 shim=input::acceleration
+    function acceleration(dimension: Dimension): number;
+
+    /**
+     * Reads the light level applied to the LED screen in a range from ``0`` (dark) to ``255`` bright. In the simulator, the ``acceleration y`` is used to emulate this value.
+     */
+    //% help=input/light-level weight=53
+    //% blockId=device_get_light_level block="light level" blockGap=8 icon="\uf185" shim=input::lightLevel
+    function lightLevel(): number;
+
+    /**
+     * The pitch of the device, rotation along the ``x-axis``, in degrees.
+     * @param kind TODO
+     */
+    //% help=/input/rotation weight=52
+    //% blockId=device_get_rotation block="rotation (°)|%NAME" blockGap=8 icon="\uf197" shim=input::rotation
+    function rotation(kind: Rotation): number;
+
+    /**
+     * Get the magnetic force value in ``micro-Teslas`` (``µT``). This function is not supported in the simulator.
+     * @param dimension TODO
+     */
+    //% help=input/magnetic-force weight=51
+    //% blockId=device_get_magnetic_force block="magnetic force (µT)|%NAME" blockGap=8 icon="\uf076" shim=input::magneticForce
+    function magneticForce(dimension: Dimension): number;
+
+    /**
+     * Gets the number of milliseconds elapsed since power on.
+     */
+    //% help=input/running-time weight=50
+    //% blockId=device_get_running_time block="running time (ms)" icon="\uf017" shim=input::runningTime
+    function runningTime(): number;
+
+    /**
+     * Obsolete, compass calibration is automatic.
+     */
+    //% help=input/calibrate weight=0 shim=input::calibrate
+    function calibrate(): void;
+
+    /**
+     * Get the pin state (pressed or not). Requires to hold the ground to close the circuit.
+     * @param name pin used to detect the touch
+     */
+    //% help=input/pin-is-pressed weight=58 block="pin|%NAME|is pressed" icon="\uf094" shim=input::pinIsPressed
+    function pinIsPressed(name: TouchPin): boolean;
+
+    /**
+     * Sets the accelerometer sample range in gravities.
+     * @param range a value describe the maximum strengh of acceleration measured
+     */
+    //% help=input/set-accelerator-range
+    //% blockId=device_set_accelerometer_range block="set accelerometer|range %range" icon="\uf135"
+    //% weight=5 shim=input::setAccelerometerRange
+    function setAccelerometerRange(range: AcceleratorRange): void;
+}
+
+
+
+    //% weight=1 color="#333333"
+declare namespace control {
+
+    /**
+     * Schedules code that run in the background.
+     */
+    //% help=control/in-background
+    //% blockId="control_in_background" block="run in background" blockGap=8 shim=control::inBackground
+    function inBackground(a: () => void): void;
+
+    /**
+     * Resets the BBC micro:bit.
+     */
+    //% weight=30 async help=control/reset
+    //% blockId="control_reset" block="reset" shim=control::reset
+    function reset(): void;
+
+    /**
+     * Raises an event in the event bus.
+     * @param src ID of the MicroBit Component that generated the event e.g. MICROBIT_ID_BUTTON_A.
+     * @param value Component specific code indicating the cause of the event.
+     * @param mode optional definition of how the event should be processed after construction (default is CREATE_AND_QUEUE).
+     */
+    //% weight=21 blockGap=12 blockId="control_raise_event" block="raise event|from source %src=control_event_source|with value %value=control_event_value" blockExternalInputs=1
+    //% mode.defl=1 shim=control::raiseEvent
+    function raiseEvent(src: number, value: number, mode: EventCreationMode): void;
+
+    /**
+     * Raises an event in the event bus.
+     */
+    //% weight=20 blockGap=8 blockId="control_on_event" block="on event|from %src=control_event_source|with value %value=control_event_value" 
+    //% blockExternalInputs=1 blockStatement=1 shim=control::onEvent
+    function onEvent(src: number, value: number, handler: () => void): void;
+}
+
+
+
+    //% color=3 weight=35
+declare namespace led {
+
+    /**
+     * Turn on the specified LED using x, y coordinates (x is horizontal, y is vertical). (0,0) is upper left.
+     * @param x TODO
+     * @param y TODO
+     */
+    //% help=led/plot weight=78
+    //% blockId=device_plot block="plot|x %x|y %y" icon="\uf205" blockGap=8 shim=led::plot
+    function plot(x: number, y: number): void;
+
+    /**
+     * Turn off the specified LED using x, y coordinates (x is horizontal, y is vertical). (0,0) is upper left.
+     * @param x TODO
+     * @param y TODO
+     */
+    //% help=led/unplot weight=77
+    //% blockId=device_unplot block="unplot|x %x|y %y" icon="\uf204" blockGap=8 shim=led::unplot
+    function unplot(x: number, y: number): void;
+
+    /**
+     * Get the on/off state of the specified LED using x, y coordinates. (0,0) is upper left.
+     * @param x TODO
+     * @param y TODO
+     */
+    //% help=led/point weight=76
+    //% blockId=device_point block="point|x %x|y %y" icon="\uf10c" shim=led::point
+    function point(x: number, y: number): boolean;
+
+    /**
+     * Get the screen brightness from 0 (off) to 255 (full bright).
+     */
+    //% help=led/brightness weight=60
+    //% blockId=device_get_brightness block="brightness" icon="\uf042" blockGap=8 shim=led::brightness
+    function brightness(): number;
+
+    /**
+     * Set the screen brightness from 0 (off) to 255 (full bright).
+     * @param value the brightness value, eg:255, 127, 0
+     */
+    //% help=led/set-brightness weight=59
+    //% blockId=device_set_brightness block="set brightness %value" icon="\uf042" shim=led::setBrightness
+    function setBrightness(value: number): void;
+
+    /**
+     * Cancels the current animation and clears other pending animations.
+     */
+    //% weight=50 help=led/stop-animation
+    //% blockId=device_stop_animation block="stop animation" icon="\uf04d" shim=led::stopAnimation
+    function stopAnimation(): void;
+
+    /**
+     * Sets the display mode between black and white and greyscale for rendering LEDs.
+     * @param mode TODO
+     */
+    //% weight=1 help=/led/set-display-mode shim=led::setDisplayMode
+    function setDisplayMode(mode: DisplayMode): void;
+
+    /**
+     * Takes a screenshot of the LED screen and returns an image.
+     */
+    //% help=led/screenshot shim=led::screenshot
+    function screenshot(): Image;
+}
+
+
+
+    //% color=351 weight=30
+declare namespace pins {
+
+    /**
+     * Read the specified pin or connector as either 0 or 1
+     * @param name pin to read from
+     */
+    //% help=pins/digital-read-pin weight=30
+    //% blockId=device_get_digital_pin block="digital read|pin %name" blockGap=8 shim=pins::digitalReadPin
+    function digitalReadPin(name: DigitalPin): number;
+
+    /**
+     * Set a pin or connector value to either 0 or 1.
+     * @param name pin to write to
+     * @param value value to set on the pin, 1 eg,0
+     */
+    //% help=pins/digital-write-pin weight=29
+    //% blockId=device_set_digital_pin block="digital write|pin %name|to %value" shim=pins::digitalWritePin
+    function digitalWritePin(name: DigitalPin, value: number): void;
+
+    /**
+     * Read the connector value as analog, that is, as a value comprised between 0 and 1023.
+     * @param name pin to write to
+     */
+    //% help=pins/analog-read-pin weight=25
+    //% blockId=device_get_analog_pin block="analog read|pin %name" blockGap="8" shim=pins::analogReadPin
+    function analogReadPin(name: AnalogPin): number;
+
+    /**
+     * Set the connector value as analog. Value must be comprised between 0 and 1023.
+     * @param name pin name to write to
+     * @param value value to write to the pin between ``0`` and ``1023``. eg:1023,0
+     */
+    //% help=pins/analog-write-pin weight=24
+    //% blockId=device_set_analog_pin block="analog write|pin %name|to %value" blockGap=8 shim=pins::analogWritePin
+    function analogWritePin(name: AnalogPin, value: number): void;
+
+    /**
+     * Configures the Pulse-width modulation (PWM) of the analog output to the given value in **microseconds** or `1/1000` milliseconds.
+     * If this pin is not configured as an analog output (using `analog write pin`), the operation has no effect.
+     * @param name analog pin to set period to
+     * @param micros period in micro seconds. eg:20000
+     */
+    //% help=pins/analog-set-period weight=23
+    //% blockId=device_set_analog_period block="analog set period|pin %pin|to (µs)%micros" shim=pins::analogSetPeriod
+    function analogSetPeriod(name: AnalogPin, micros: number): void;
+
+    /**
+     * Writes a value to the servo, controlling the shaft accordingly. On a standard servo, this will set the angle of the shaft (in degrees), moving the shaft to that orientation. On a continuous rotation servo, this will set the speed of the servo (with ``0`` being full-speed in one direction, ``180`` being full speed in the other, and a value near ``90`` being no movement).
+     * @param name pin to write to
+     * @param value angle or rotation speed, eg:180,90,0
+     */
+    //% help=pins/servo-write-pin weight=20
+    //% blockId=device_set_servo_pin block="servo write|pin %name|to %value" blockGap=8 shim=pins::servoWritePin
+    function servoWritePin(name: AnalogPin, value: number): void;
+
+    /**
+     * Configures this IO pin as an analog/pwm output, configures the period to be 20 ms, and sets the pulse width, based on the value it is given **microseconds** or `1/1000` milliseconds.
+     * @param name pin name
+     * @param micros pulse duration in micro seconds, eg:1500
+     */
+    //% help=pins/serial-set-pulse weight=19
+    //% blockId=device_set_servo_pulse block="servo set pulse|pin %value|to (µs) %micros" shim=pins::servoSetPulse
+    function servoSetPulse(name: AnalogPin, micros: number): void;
+
+    /**
+     * Sets the pin used when using `pins->analog pitch`.
+     * @param name TODO
+     */
+    //% help=pins/analog-set-pitch weight=12 shim=pins::analogSetPitchPin
+    function analogSetPitchPin(name: AnalogPin): void;
+
+    /**
+     * Emits a Pulse-width modulation (PWM) signal to the current pitch pin. Use `analog set pitch pin` to define the pitch pin.
+     * @param frequency TODO
+     * @param ms TODO
+     */
+    //% help=pins/analog-pitch weight=14 async shim=pins::analogPitch
+    function analogPitch(frequency: number, ms: number): void;
+
+    /**
+     * Create a new zero-initialized buffer.
+     * @param size number of bytes in the buffer
+     */
+    //% shim=pins::createBuffer
+    function createBuffer(size: number): Buffer;
+
+    /**
+     * Read `size` bytes from a 7-bit I2C `address`.
+     */
+    //% repeat.defl=0 shim=pins::i2cReadBuffer
+    function i2cReadBuffer(address: number, size: number, repeat: boolean): Buffer;
+
+    /**
+     * Write bytes to a 7-bit I2C `address`.
+     */
+    //% repeat.defl=0 shim=pins::i2cWriteBuffer
+    function i2cWriteBuffer(address: number, buf: Buffer, repeat: boolean): void;
+}
+
+
+
+    //% weight=2 color=30
+declare namespace serial {
+
+    /**
+     * Reads a line of text from the serial port.
+     */
+    //% shim=serial::readString
+    function readString(): string;
+
+    /**
+     * Sends a piece of text through Serial connection.
+     */
+    //% shim=serial::writeString
+    function writeString(text: string): void;
+
+    /**
+     * Sends the current pixel values, byte-per-pixel, over serial.
+     */
+    //% shim=serial::writeScreen
+    function writeScreen(): void;
+
+    /**
+     * Reads the screen from serial.
+     */
+    //% shim=serial::readScreen
+    function readScreen(): void;
+}
+
+
+
+    //% indexerGet=BufferMethods::getByte indexerSet=BufferMethods::setByte
+declare interface Buffer {
+    /**
+     * Write a number in specified format in the buffer.
+     */
+    //% shim=BufferMethods::setNumber
+    setNumber(format: NumberFormat, offset: number, value: number): void;
+
+    /**
+     * Read a number in specified format from the buffer.
+     */
+    //% shim=BufferMethods::getNumber
+    getNumber(format: NumberFormat, offset: number): number;
+
+    /** Returns the length of a Buffer object. */
+    //% property shim=BufferMethods::length
+    length: number;
+
+    /**
+     * Fill (a fragment) of the buffer with given value.
+     */
+    //% offset.defl=0 length.defl=-1 shim=BufferMethods::fill
+    fill(value: number, offset?: number, length?: number): void;
+
+    /**
+     * Return a copy of a fragment of a buffer.
+     */
+    //% offset.defl=0 length.defl=-1 shim=BufferMethods::slice
+    slice(offset?: number, length?: number): Buffer;
+
+    /**
+     * Shift buffer left in place, with zero padding.
+     * @param offset number of bytes to shift; use negative value to shift right
+     */
+    //% shim=BufferMethods::shift
+    shift(offset: number): void;
+
+    /**
+     * Rotate buffer left in place.
+     * @param offset number of bytes to shift; use negative value to shift right
+     */
+    //% shim=BufferMethods::rotate
+    rotate(offset: number): void;
+
+    /**
+     * Write contents of `src` at `dstOffset` in current buffer.
+     */
+    //% shim=BufferMethods::write
+    write(dstOffset: number, src: Buffer): void;
+}
+
+// Auto-generated. Do not edit. Really.

libs/neopixel/kind.json

@@ -0,0 +1,20 @@
+{
+    "name": "neppixel",
+    "description": "AdaFruit NeoPixel driver for micro:bit",
+    "files": [
+        "neopixel.ts",
+        "sendbuffer.asm"
+    ],
+    "testFiles": [
+        "neotest.ts"
+    ],
+    "microbit": {
+        "config": {
+            "MICROBIT_BLE_ENABLED": "0"
+        }
+    },
+    "public": true,
+    "dependencies": {
+        "microbit": "file:../microbit"
+    }
+}

libs/neopixel/neopixel.ts

@@ -0,0 +1,88 @@
+namespace neopixel {
+
+    //% shim=sendBufferAsm
+    function sendBuffer(buf: Buffer, pin: DigitalPin) {
+    }
+
+    class Strip {
+        buf: Buffer;
+        pin: DigitalPin;
+        brightness: number;
+
+        length() {
+            return this.buf.length / 3
+        }
+
+        /**
+         * Set the brightness of the strip, 0-255.
+         */
+        setBrigthness(brightness: number): void {
+            this.brightness = brightness;
+        }
+
+        /**
+         * Set the pin where the neopixel is connected, defaults to P0.
+         */
+        setPin(pin: DigitalPin): void {
+            this.pin = pin;
+            pins.digitalWritePin(this.pin, 0)
+            basic.pause(50)
+        }
+
+        /**
+         * Turn off all LEDs.
+         */
+        clear(): void {
+            this.buf.fill(0);
+        }
+
+        /**
+         * Shift LEDs forward.
+         */
+        shift(off: number): void {
+            this.buf.shift(-off * 3)
+        }
+
+        /**
+         * Shift LEDs forward.
+         */
+        rotate(): void {
+            this.buf.rotate(-3)
+        }
+
+        display() {
+            basic.pause(1)
+            sendBuffer(this.buf, this.pin);
+        }
+
+        /**
+         * Set give LED to a given color (range 0-255 for r, g, b)
+         */
+        setPix(ledoff: number, r: number, g: number, b: number): void {
+            ledoff = ledoff * 3;
+            let br = this.brightness;
+            if (br < 255) {
+                r = (Math.clamp(0, 255, r) * br) >> 8;
+                g = (Math.clamp(0, 255, b) * br) >> 8;
+                b = (Math.clamp(0, 255, b) * br) >> 8;
+            }
+            let buf = this.buf;
+            buf[ledoff + 0] = Math.clamp(0, 255, g);
+            buf[ledoff + 1] = Math.clamp(0, 255, r);
+            buf[ledoff + 2] = Math.clamp(0, 255, b);
+        }
+    }
+
+    /**
+     * Create a new NeoPixel driver for `numleds` LEDs.
+     * @params numleds number of leds in the strip, eg: 24,30,60,64
+     */
+    export function create(numleds: number): Strip {
+        let strip = new Strip();
+        strip.buf = pins.createBuffer(numleds * 3);
+        strip.setBrigthness(255)
+        strip.setPin(DigitalPin.P0)
+        return strip;
+    }
+
+}

libs/neopixel/neotest.ts

@@ -0,0 +1,92 @@
+basic.showLeds(`
+    # . . . .
+    . . . . .
+    . . # . .
+    . . . . .
+    . . . . #
+    `)
+console.log("Start")
+
+// Create a NeoPixel driver - specify the number of LEDs:
+let strip = neopixel.create(7);
+
+// If your strip is not at P0, specify the pin.
+strip.setPin(DigitalPin.P0)
+
+// Brightness defaults to 255 (very bright); 0 is completely off.
+strip.setBrigthness(20)
+
+// Set pixels - pixel number, followed by red, green and blue values, between 0 and 255.
+strip.setPix(0, 255, 255, 255);
+strip.setPix(1, 0, 255, 255);
+strip.setPix(2, 255, 0, 255);
+strip.setPix(3, 255, 255, 0);
+
+console.log("Send!")
+
+// Send the image to the strip.
+strip.display();
+basic.pause(500);
+
+console.log("Sent!")
+
+// Green light travelling the strip:
+for (let l = 0; l < strip.length(); l++) {
+    strip.clear();
+    strip.setPix(l, 0, 255, 0);
+    strip.display();
+    basic.pause(100);
+}
+
+let special = false;
+let numcol = 0;
+input.onButtonPressed(Button.A, () => {
+    special = true;
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    if (numcol == 0) {
+        r = 255;
+        g = 255;
+        b = 255;
+    } else if (numcol == 1) {
+        r = 255;
+    } else if (numcol == 2) {
+        b = 255;
+    } else if (numcol == 3) {
+        r = 255;
+        g = 255;
+    } else if (numcol == 4) {
+        r = 10;
+        g = 10;
+        b = 10;
+    }
+    numcol = (numcol + 1) % 5;
+    for (let k = 0; k < 7; k++) {
+        strip.setPix(k, r, g, b);
+    }
+    strip.display();
+});
+
+control.inBackground(() => {
+    for (let j = 0; j < 2000000; j++) {
+        if (special) {
+            basic.pause(100);
+            continue;
+        }
+        let r1 = (0 + j * 2) & 63;
+        let g1 = (20 + j * 1) & 63;
+        let b1 = (30 + j * 3) & 63;
+        for (let i = 0; i < strip.length(); i++) {
+            strip.setPix(i, (r1 - i) * 20, (g1 - i) * 20, (b1 - i) * 20);
+        }
+        strip.display()
+        basic.pause(60);
+    }
+});
+
+control.inBackground(() => {
+    while (true) {
+        basic.showString("XMAS!", 150);
+    }
+});

libs/neopixel/sendbuffer.asm

@@ -0,0 +1,67 @@
+sendBufferAsm:
+
+    push {r4,r5,r6,r7,lr}
+    
+    mov r4, r0 ; save buff
+    mov r6, r1 ; save pin
+    
+    mov r0, r4
+    bl BufferMethods::length
+    mov r5, r0
+    
+    mov r0, r4
+    bl BufferMethods::getBytes
+    mov r4, r0
+    
+    ; setup pin as digital
+    mov r0, r6
+    movs r1, #0
+    bl pins::digitalWritePin
+    
+    ; load pin address
+    mov r0, r6
+    bl pins::getPinAddress
+
+    ldr r0, [r0, #8] ; get mbed DigitalOut from MicroBitPin
+    ldr r1, [r0, #4] ; r1-mask for this pin
+    ldr r2, [r0, #16] ; r2-clraddr
+    ldr r3, [r0, #12] ; r3-setaddr
+    
+    cpsid i ; disable irq
+    
+    b .start
+    
+.nextbit:               ;            C0
+    str r1, [r3, #0]    ; pin := hi  C2
+    tst r6, r0          ;            C3
+    bne .islate         ;            C4
+    str r1, [r2, #0]    ; pin := lo  C6
+.islate:
+    lsrs r6, r6, #1     ; r6 >>= 1   C7
+    bne .justbit        ;            C8
+    
+    ; not just a bit - need new byte
+    adds r4, #1         ; r4++       C9
+    subs r5, #1         ; r5--       C10
+    bcc .stop           ; if (r5<0) goto .stop  C11
+.start:
+    movs r6, #0x80      ; reset mask C12
+    nop                 ;            C13
+
+.common:               ;             C13
+    str r1, [r2, #0]   ; pin := lo   C15
+    ; always re-load byte - it just fits with the cycles better this way
+    ldrb r0, [r4, #0]  ; r0 := *r4   C17
+    b .nextbit         ;             C20
+
+.justbit: ; C10
+    ; no nops, branch taken is already 3 cycles
+    b .common ; C13
+
+.stop:    
+    str r1, [r2, #0]   ; pin := lo
+    cpsie i            ; enable irq
+
+    pop {r4,r5,r6,r7,pc}
+
+

package.json

@@ -1,6 +1,6 @@
 {
   "name": "kindscript-microbit",
-  "version": "0.2.9",
+  "version": "0.2.16",
   "description": "BBC micro:bit target for KindScript",
   "keywords": [
     "JavaScript",
@@ -17,7 +17,6 @@
   "files": [
     "README.md",
     "kindtarget.json",
-    "kindtheme.json",
     "built/*.js",
     "built/*.json",
     "built/*.d.ts",
@@ -30,6 +29,6 @@
     "typescript": "^1.8.7"
   },
   "dependencies": {
-    "kindscript": "0.2.9"
+    "kindscript": "0.2.18"
   }
 }

sim/enums.ts

@@ -1,99 +0,0 @@
-namespace ks.rt.micro_bit {
-    export interface Enums {
-        MES_ALERT_EVT_ALARM1: number;
-        MES_ALERT_EVT_ALARM2: number;
-        MES_ALERT_EVT_ALARM3: number;
-        MES_ALERT_EVT_ALARM4: number;
-        MES_ALERT_EVT_ALARM5: number;
-        MES_ALERT_EVT_ALARM6: number;
-        MES_ALERT_EVT_DISPLAY_TOAST: number;
-        MES_ALERT_EVT_FIND_MY_PHONE: number;
-        MES_ALERT_EVT_PLAY_RINGTONE: number;
-        MES_ALERT_EVT_PLAY_SOUND: number;
-        MES_ALERT_EVT_VIBRATE: number;
-        MES_CAMERA_EVT_LAUNCH_PHOTO_MODE: number;
-        MES_CAMERA_EVT_LAUNCH_VIDEO_MODE: number;
-        MES_CAMERA_EVT_START_VIDEO_CAPTURE: number;
-        MES_CAMERA_EVT_STOP_PHOTO_MODE: number;
-        MES_CAMERA_EVT_STOP_VIDEO_CAPTURE: number;
-        MES_CAMERA_EVT_STOP_VIDEO_MODE: number;
-        MES_CAMERA_EVT_TAKE_PHOTO: number;
-        MES_CAMERA_EVT_TOGGLE_FRONT_REAR: number;
-        MES_DEVICE_DISPLAY_OFF: number;
-        MES_DEVICE_DISPLAY_ON: number;
-        MES_DEVICE_GESTURE_DEVICE_SHAKEN: number;
-        MES_DEVICE_INCOMING_CALL: number;
-        MES_DEVICE_INCOMING_MESSAGE: number;
-        MES_DEVICE_ORIENTATION_LANDSCAPE: number;
-        MES_DEVICE_ORIENTATION_PORTRAIT: number;
-        MES_DPAD_BUTTON_1_DOWN: number;
-        MES_DPAD_BUTTON_1_UP: number;
-        MES_DPAD_BUTTON_2_DOWN: number;
-        MES_DPAD_BUTTON_2_UP: number;
-        MES_DPAD_BUTTON_3_DOWN: number;
-        MES_DPAD_BUTTON_3_UP: number;
-        MES_DPAD_BUTTON_4_DOWN: number;
-        MES_DPAD_BUTTON_4_UP: number;
-        MES_DPAD_BUTTON_A_DOWN: number;
-        MES_DPAD_BUTTON_A_UP: number;
-        MES_DPAD_BUTTON_B_DOWN: number;
-        MES_DPAD_BUTTON_B_UP: number;
-        MES_DPAD_BUTTON_C_DOWN: number;
-        MES_DPAD_BUTTON_C_UP: number;
-        MES_DPAD_BUTTON_D_DOWN: number;
-        MES_DPAD_BUTTON_D_UP: number;
-        MES_REMOTE_CONTROL_EVT_FORWARD: number;
-        MES_REMOTE_CONTROL_EVT_NEXTTRACK: number;
-        MES_REMOTE_CONTROL_EVT_PAUSE: number;
-        MES_REMOTE_CONTROL_EVT_PLAY: number;
-        MES_REMOTE_CONTROL_EVT_PREVTRACK: number;
-        MES_REMOTE_CONTROL_EVT_REWIND: number;
-        MES_REMOTE_CONTROL_EVT_STOP: number;
-        MES_REMOTE_CONTROL_EVT_VOLUMEDOWN: number;
-        MES_REMOTE_CONTROL_EVT_VOLUMEUP: number;
-        MICROBIT_ID_BUTTON_A: number;
-        MICROBIT_ID_BUTTON_B: number;
-        MICROBIT_ID_BUTTON_AB: number;
-        MICROBIT_BUTTON_EVT_CLICK: number;
-        MICROBIT_ID_IO_P0: number;
-        MICROBIT_ID_IO_P1: number;
-        MICROBIT_ID_IO_P2: number;
-        MICROBIT_ID_IO_P3: number;
-        MICROBIT_ID_IO_P4: number;
-        MICROBIT_ID_IO_P5: number;
-        MICROBIT_ID_IO_P6: number;
-        MICROBIT_ID_IO_P7: number;
-        MICROBIT_ID_IO_P8: number;
-        MICROBIT_ID_IO_P9: number;
-        MICROBIT_ID_IO_P10: number;
-        MICROBIT_ID_IO_P11: number;
-        MICROBIT_ID_IO_P12: number;
-        MICROBIT_ID_IO_P13: number;
-        MICROBIT_ID_IO_P14: number;
-        MICROBIT_ID_IO_P15: number;
-        MICROBIT_ID_IO_P16: number;
-        MICROBIT_ID_IO_P19: number;
-        MICROBIT_ID_IO_P20: number;
-        MES_BROADCAST_GENERAL_ID: number;
-        MICROBIT_ID_RADIO: number;
-        MICROBIT_RADIO_EVT_DATAGRAM: number;
-        MICROBIT_ID_GESTURE: number;
-        MICROBIT_ACCELEROMETER_REST_TOLERANCE: number;
-        MICROBIT_ACCELEROMETER_TILT_TOLERANCE: number;
-        MICROBIT_ACCELEROMETER_FREEFALL_TOLERANCE: number;
-        MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE: number;
-        MICROBIT_ACCELEROMETER_3G_TOLERANCE: number;
-        MICROBIT_ACCELEROMETER_6G_TOLERANCE: number;
-        MICROBIT_ACCELEROMETER_8G_TOLERANCE: number;
-        MICROBIT_ACCELEROMETER_GESTURE_DAMPING: number;
-        MICROBIT_ACCELEROMETER_SHAKE_DAMPING: number;
-        MICROBIT_ACCELEROMETER_REST_THRESHOLD: number;
-        MICROBIT_ACCELEROMETER_FREEFALL_THRESHOLD: number;
-        MICROBIT_ACCELEROMETER_3G_THRESHOLD: number;
-        MICROBIT_ACCELEROMETER_6G_THRESHOLD: number;
-        MICROBIT_ACCELEROMETER_8G_THRESHOLD: number;
-        MICROBIT_ACCELEROMETER_SHAKE_COUNT_THRESHOLD: number;
-        MICROBIT_ACCELEROMETER_EVT_DATA_UPDATE: number;
-        MICROBIT_ID_ACCELEROMETER: number;
-    }
-}

sim/libmbit.ts

@@ -1,22 +1,17 @@
 /// <reference path="../node_modules/kindscript/typings/bluebird/bluebird.d.ts"/>
 /// <reference path="../node_modules/kindscript/built/kindsim.d.ts"/>
+/// <reference path="../libs/microbit/dal.d.ts"/>
 
-namespace ks.rt.micro_bit {
-    export function initCurrentRuntime() {
+namespace ks.rt {
+    ks.rt.initCurrentRuntime = () => {
         U.assert(!runtime.board)
         runtime.board = new Board()
     }
 
-    ks.rt.initCurrentRuntime = initCurrentRuntime;
-
     export function board() {
         return runtime.board as Board
     }
 
-    export function enums() {
-        return runtime.enums as any as Enums
-    }
-
     export interface AnimationOptions {
         interval: number;
         // false means last frame
@@ -88,209 +83,12 @@ namespace ks.rt.micro_bit {
         throw new Error("PANIC " + code)
     }
 
-    /* leds */
-    export function plot(x: number, y: number) {
-        board().image.set(x, y, 255);
-        runtime.queueDisplayUpdate()
+    export function getPin(id: number) {
+        return board().pins.filter(p => p && p.id == id)[0] || null
     }
 
-    export function unPlot(x: number, y: number) {
-        board().image.set(x, y, 0);
-        runtime.queueDisplayUpdate()
-    }
 
-    export function point(x: number, y: number): boolean {
-        return !!board().image.get(x, y);
-    }
-
-    export function brightness(): number {
-        return board().brigthness;
-    }
-
-    export function setBrightness(value: number): void {
-        board().brigthness = value;
-        runtime.queueDisplayUpdate()
-    }
-
-    export function stopAnimation(): void {
-        board().animationQ.cancelAll();
-    }
-
-    export function plotLeds(leds: micro_bit.Image): void {
-        leds.copyTo(0, 5, board().image, 0)
-        runtime.queueDisplayUpdate()
-    }
-
-    export function setDisplayMode(mode: DisplayMode): void {
-        board().displayMode = mode;
-        runtime.queueDisplayUpdate()
-    }
-
-    /* serial */
-    export function serialSendString(s: string) {
-        board().writeSerial(s);
-    }
-
-    export function serialReadString(): string {
-        return board().readSerial();
-    }
-
-    /* input */
-    export function onButtonPressed(button: number, handler: RefAction): void {
-        let ens = enums();
-        let b = board();
-        if (button == ens.MICROBIT_ID_BUTTON_AB && !board().usesButtonAB) {
-            b.usesButtonAB = true;
-            runtime.queueDisplayUpdate();
-        }
-        b.bus.listen(button, ens.MICROBIT_BUTTON_EVT_CLICK, handler);
-    }
-
-    export function isButtonPressed(button: number): boolean {
-        let ens = enums();
-        let b = board();
-        if (button == ens.MICROBIT_ID_BUTTON_AB && !board().usesButtonAB) {
-            b.usesButtonAB = true;
-            runtime.queueDisplayUpdate();
-        }
-        let bts = b.buttons;
-        if (button == ens.MICROBIT_ID_BUTTON_A) return bts[0].pressed;
-        if (button == ens.MICROBIT_ID_BUTTON_B) return bts[1].pressed;
-        return bts[2].pressed || (bts[0].pressed && bts[1].pressed);
-    }
-
-    export function onGesture(gesture: number, handler: RefAction) {
-        let ens = enums();
-        let b = board();
-        b.accelerometer.activate();
-
-        if (gesture == 11 && !b.useShake) { // SAKE
-            b.useShake = true;
-            runtime.queueDisplayUpdate();
-        }
-        b.bus.listen(ens.MICROBIT_ID_GESTURE, gesture, handler);
-    }
-
-    export function onPinPressed(pin: Pin, handler: RefAction) {
-        pin.isTouched();
-        onButtonPressed(pin.id, handler);
-    }
-
-    export function ioP0() { return board().pins[0]; }
-    export function ioP1() { return board().pins[1]; }
-    export function ioP2() { return board().pins[2]; }
-    export function ioP3() { return board().pins[3]; }
-    export function ioP4() { return board().pins[4]; }
-    export function ioP5() { return board().pins[5]; }
-    export function ioP6() { return board().pins[6]; }
-    export function ioP7() { return board().pins[7]; }
-    export function ioP8() { return board().pins[8]; }
-    export function ioP9() { return board().pins[9]; }
-    export function ioP10() { return board().pins[10]; }
-    export function ioP11() { return board().pins[11]; }
-    export function ioP12() { return board().pins[12]; }
-    export function ioP13() { return board().pins[13]; }
-    export function ioP14() { return board().pins[14]; }
-    export function ioP15() { return board().pins[15]; }
-    export function ioP16() { return board().pins[16]; }
-    export function ioP19() { return board().pins[19]; }
-    export function ioP20() { return board().pins[20]; }
-
-    export function isPinTouched(pin: Pin): boolean {
-        return pin.isTouched();
-    }
-
-    export function compassHeading(): number {
-        var b = board();
-        if (!b.usesHeading) {
-            b.usesHeading = true;
-            runtime.queueDisplayUpdate();
-        }
-        return b.heading;
-    }
-
-    export function temperature(): number {
-        var b = board();
-        if (!b.usesTemperature) {
-            b.usesTemperature = true;
-            runtime.queueDisplayUpdate();
-        }
-        return b.temperature;
-    }
-
-    export function getAcceleration(dimension: number): number {
-        let b = board();
-        let acc = b.accelerometer;
-        acc.activate();
-        switch (dimension) {
-            case 0: return acc.getX();
-            case 1: return acc.getY();
-            case 2: return acc.getZ();
-            default: return Math.floor(Math.sqrt(acc.instantaneousAccelerationSquared()));
-        }
-    }
-
-    export function setAccelerometerRange(range: number) {
-        let b = board();
-        b.accelerometer.setSampleRange(range);
-    }
-
-    export function lightLevel(): number {
-        let b = board();
-        if (!b.usesLightLevel) {
-            b.usesLightLevel = true;
-            runtime.queueDisplayUpdate();
-        }
-        return b.lightLevel;
-    }
-
-    export function getMagneticForce(): number {
-        // TODO
-        return 0;
-    }
-
-    export function getCurrentTime(): number {
-        return runtime.runningTime();
-    }
-
-    /* pins */
-    export function digitalReadPin(pin: Pin): number {
-        pin.mode = PinMode.Digital | PinMode.Input;
-        return pin.value > 100 ? 1 : 0;
-    }
-
-    export function digitalWritePin(pin: Pin, value: number) {
-        pin.mode = PinMode.Digital | PinMode.Output;
-        pin.value = value > 0 ? 1023 : 0;
-        runtime.queueDisplayUpdate();
-    }
-
-    export function analogReadPin(pin: Pin): number {
-        pin.mode = PinMode.Analog | PinMode.Input;
-        return pin.value || 0;
-    }
-
-    export function analogWritePin(pin: Pin, value: number) {
-        pin.mode = PinMode.Analog | PinMode.Output;
-        pin.value = value ? 1 : 0;
-        runtime.queueDisplayUpdate();
-    }
-
-    export function setAnalogPeriodUs(pin: Pin, micros: number) {
-        pin.mode = PinMode.Analog | PinMode.Output;
-        pin.period = micros;
-        runtime.queueDisplayUpdate();
-    }
-
-    export function servoWritePin(pin: Pin, value: number) {
-        setAnalogPeriodUs(pin, 20000);
-        // TODO
-    }
-
-    export function servoSetPulse(pin: Pin, micros: number) {
-    }
-
-    module AudioContextManager {
+    export namespace AudioContextManager {
         var _context: any; // AudioContext
         var _vco: any; //OscillatorNode;
         var _vca: any; // GainNode;
@@ -342,12 +140,350 @@ namespace ks.rt.micro_bit {
         }
     }
 
-    export function enablePitch(pin: Pin) {
+
+}
+
+namespace ks.rt.basic {
+    export var pause = thread.pause;
+
+    export function showNumber(x: number, interval: number) {
+        if (interval < 0) return;
+
+        let leds = createImageFromString(x.toString());
+        if (x < 0 || x >= 10) scrollImage(leds, interval, 1);
+        else showLeds(leds, interval * 5);
+    }
+
+    export function showString(s: string, interval: number) {
+        if (interval < 0) return;
+        if (s.length == 0) {
+            clearScreen();
+            pause(interval * 5);
+        } else {
+            let leds = createImageFromString(s);
+            if (s.length == 1) showLeds(leds, interval * 5)
+            else scrollImage(leds, interval, 1);
+        }
+    }
+
+    export function showLeds(leds: Image, delay: number): void {
+        showAnimation(leds, delay);
+    }
+
+    export function clearScreen() {
+        board().image.clear();
+        runtime.queueDisplayUpdate()
+    }
+
+    function scrollImage(leds: Image, interval: number, stride: number): void {
+        let cb = getResume()
+        let off = stride > 0 ? 0 : leds.width - 1;
+        let display = board().image;
+
+        board().animationQ.enqueue({
+            interval: interval,
+            frame: () => {
+                if (off >= leds.width || off < 0) return false;
+                stride > 0 ? display.shiftLeft(stride) : display.shiftRight(-stride);
+                let c = Math.min(stride, leds.width - off);
+                leds.copyTo(off, c, display, 5 - stride)
+                off += stride;
+                return true;
+            },
+            whenDone: cb
+        })
+    }
+
+    export function showAnimation(leds: Image, interval: number = 400): void {
+        scrollImage(leds, interval, 5);
+    }
+
+    export function forever(a: RefAction) {
+        function loop() {
+            runtime.runFiberAsync(a)
+                .then(() => Promise.delay(20))
+                .then(loop)
+                .done()
+        }
+        incr(a)
+        loop()
+    }
+
+    export function plotLeds(leds: Image): void {
+        leds.copyTo(0, 5, board().image, 0)
+        runtime.queueDisplayUpdate()
+    }
+}
+
+namespace ks.rt.control {
+    export var inBackground = thread.runInBackground;
+
+    export function reset() {
+        U.userError("reset not implemented in simulator yet")
+    }
+
+    export function onEvent(id: number, evid: number, handler: RefAction) {
+        kindscript.registerWithDal(id, evid, handler)
+    }
+
+    export function raiseEvent(id: number, evid: number, mode: number) {
+        // TODO mode?
+        board().bus.queue(id, evid)
+    }
+}
+
+namespace ks.rt.kindscript {
+    export function registerWithDal(id: number, evid: number, handler: RefAction) {
+        board().bus.listen(id, evid, handler);
+    }
+}
+
+namespace ks.rt.input {
+    export function onButtonPressed(button: number, handler: RefAction): void {
+        let b = board();
+        if (button == DAL.MICROBIT_ID_BUTTON_AB && !board().usesButtonAB) {
+            b.usesButtonAB = true;
+            runtime.queueDisplayUpdate();
+        }
+        b.bus.listen(button, DAL.MICROBIT_BUTTON_EVT_CLICK, handler);
+    }
+
+    export function buttonIsPressed(button: number): boolean {
+        let b = board();
+        if (button == DAL.MICROBIT_ID_BUTTON_AB && !board().usesButtonAB) {
+            b.usesButtonAB = true;
+            runtime.queueDisplayUpdate();
+        }
+        let bts = b.buttons;
+        if (button == DAL.MICROBIT_ID_BUTTON_A) return bts[0].pressed;
+        if (button == DAL.MICROBIT_ID_BUTTON_B) return bts[1].pressed;
+        return bts[2].pressed || (bts[0].pressed && bts[1].pressed);
+    }
+
+    export function onGesture(gesture: number, handler: RefAction) {
+        let b = board();
+        b.accelerometer.activate();
+
+        if (gesture == 11 && !b.useShake) { // SAKE
+            b.useShake = true;
+            runtime.queueDisplayUpdate();
+        }
+        b.bus.listen(DAL.MICROBIT_ID_GESTURE, gesture, handler);
+    }
+
+    export function onPinPressed(pinId: number, handler: RefAction) {
+        let pin = getPin(pinId);
+        if (!pin) return;
+        pin.isTouched();
+        input.onButtonPressed(pin.id, handler);
+    }
+
+    export function pinIsPressed(pinId: number): boolean {
+        let pin = getPin(pinId);
+        if (!pin) return false;
+        return pin.isTouched();
+    }
+
+
+
+    export function compassHeading(): number {
+        var b = board();
+        if (!b.usesHeading) {
+            b.usesHeading = true;
+            runtime.queueDisplayUpdate();
+        }
+        return b.heading;
+    }
+
+    export function temperature(): number {
+        var b = board();
+        if (!b.usesTemperature) {
+            b.usesTemperature = true;
+            runtime.queueDisplayUpdate();
+        }
+        return b.temperature;
+    }
+
+    export function acceleration(dimension: number): number {
+        let b = board();
+        let acc = b.accelerometer;
+        acc.activate();
+        switch (dimension) {
+            case 0: return acc.getX();
+            case 1: return acc.getY();
+            case 2: return acc.getZ();
+            default: return Math.floor(Math.sqrt(acc.instantaneousAccelerationSquared()));
+        }
+    }
+
+    export function setAccelerometerRange(range: number) {
+        let b = board();
+        b.accelerometer.setSampleRange(range);
+    }
+
+    export function lightLevel(): number {
+        let b = board();
+        if (!b.usesLightLevel) {
+            b.usesLightLevel = true;
+            runtime.queueDisplayUpdate();
+        }
+        return b.lightLevel;
+    }
+
+    export function magneticForce(): number {
+        // TODO
+        return 0;
+    }
+
+    export function runningTime(): number {
+        return runtime.runningTime();
+    }
+
+    export function calibrate() {
+    }
+}
+
+namespace ks.rt.led {
+    export function plot(x: number, y: number) {
+        board().image.set(x, y, 255);
+        runtime.queueDisplayUpdate()
+    }
+
+    export function unplot(x: number, y: number) {
+        board().image.set(x, y, 0);
+        runtime.queueDisplayUpdate()
+    }
+
+    export function point(x: number, y: number): boolean {
+        return !!board().image.get(x, y);
+    }
+
+    export function brightness(): number {
+        return board().brigthness;
+    }
+
+    export function setBrightness(value: number): void {
+        board().brigthness = value;
+        runtime.queueDisplayUpdate()
+    }
+
+    export function stopAnimation(): void {
+        board().animationQ.cancelAll();
+    }
+
+    export function setDisplayMode(mode: DisplayMode): void {
+        board().displayMode = mode;
+        runtime.queueDisplayUpdate()
+    }
+}
+
+namespace ks.rt.serial {
+    export function writeString(s: string) {
+        board().writeSerial(s);
+    }
+
+    export function readString(): string {
+        return board().readSerial();
+    }
+}
+
+
+namespace ks.rt.radio {
+    export function broadcastMessage(msg: number): void {
+        board().radio.broadcast(msg);
+    }
+
+    export function onBroadcastMessageReceived(msg: number, handler: RefAction): void {
+        board().bus.listen(DAL.MES_BROADCAST_GENERAL_ID, msg, handler);
+    }
+
+    export function setGroup(id: number): void {
+        board().radio.setGroup(id);
+    }
+
+    export function setTransmitPower(power: number): void {
+        board().radio.setTransmitPower(power);
+    }
+
+    export function sendNumbers(value0: number, value1: number, value2: number, value3: number): void {
+        board().radio.datagram.send([value0, value1, value2, value3]);
+    }
+
+    export function receiveNumber(): number {
+        return board().radio.datagram.recv().data[0];
+    }
+
+    export function receivedNumberAt(index: number): number {
+        return board().radio.datagram.lastReceived.data[index] || 0;
+    }
+
+    export function receivedSignalStrength(): number {
+        return board().radio.datagram.lastReceived.rssi;
+    }
+
+    export function onDataReceived(handler: RefAction): void {
+        board().bus.listen(DAL.MICROBIT_ID_RADIO, DAL.MICROBIT_RADIO_EVT_DATAGRAM, handler);
+    }
+}
+
+namespace ks.rt.pins {
+    export function digitalReadPin(pinId: number): number {
+        let pin = getPin(pinId);
+        if (!pin) return;
+        pin.mode = PinMode.Digital | PinMode.Input;
+        return pin.value > 100 ? 1 : 0;
+    }
+
+    export function digitalWritePin(pinId: number, value: number) {
+        let pin = getPin(pinId);
+        if (!pin) return;
+        pin.mode = PinMode.Digital | PinMode.Output;
+        pin.value = value > 0 ? 1023 : 0;
+        runtime.queueDisplayUpdate();
+    }
+
+    export function analogReadPin(pinId: number): number {
+        let pin = getPin(pinId);
+        if (!pin) return;
+        pin.mode = PinMode.Analog | PinMode.Input;
+        return pin.value || 0;
+    }
+
+    export function analogWritePin(pinId: number, value: number) {
+        let pin = getPin(pinId);
+        if (!pin) return;
+        pin.mode = PinMode.Analog | PinMode.Output;
+        pin.value = value ? 1 : 0;
+        runtime.queueDisplayUpdate();
+    }
+
+    export function analogSetPeriod(pinId: number, micros: number) {
+        let pin = getPin(pinId);
+        if (!pin) return;
+        pin.mode = PinMode.Analog | PinMode.Output;
+        pin.period = micros;
+        runtime.queueDisplayUpdate();
+    }
+
+    export function servoWritePin(pinId: number, value: number) {
+        analogSetPeriod(pinId, 20000);
+        // TODO
+    }
+
+    export function servoSetPulse(pinId: number, micros: number) {
+        let pin = getPin(pinId);
+        if (!pin) return;
+        // TODO
+    }
+
+    export function analogSetPitchPin(pinId: number) {
+        let pin = getPin(pinId);
+        if (!pin) return;
         board().pins.filter(p => !!p).forEach(p => p.pitch = false);
         pin.pitch = true;
     }
 
-    export function pitch(frequency: number, ms: number) {
+    export function analogPitch(frequency: number, ms: number) {
         // update analog output
         let pin = board().pins.filter(pin => !!pin && pin.pitch)[0] || board().pins[0];
         pin.mode = PinMode.Analog | PinMode.Output;
@@ -376,119 +512,19 @@ namespace ks.rt.micro_bit {
     }
 
 
-    /* radio */
-    export function broadcastMessage(msg: number): void {
-        board().radio.broadcast(msg);
-    }
-
-    export function onBroadcastMessageReceived(msg: number, handler: RefAction): void {
-        let ens = enums()
-        board().bus.listen(ens.MES_BROADCAST_GENERAL_ID, msg, handler);
-    }
-
-    export function setGroup(id: number): void {
-        board().radio.setGroup(id);
-    }
-
-    export function setTransmitPower(power: number): void {
-        board().radio.setTransmitPower(power);
-    }
-
-    export function datagramSendNumbers(value0: number, value1: number, value2: number, value3: number): void {
-        board().radio.datagram.send([value0, value1, value2, value3]);
-    }
-
-    export function datagramReceiveNumber(): number {
-        return board().radio.datagram.recv().data[0];
-    }
-
-    export function datagramGetNumber(index: number): number {
-        return board().radio.datagram.lastReceived.data[index] || 0;
-    }
-
-    export function datagramGetRSSI(): number {
-        return board().radio.datagram.lastReceived.rssi;
-    }
-
-    export function onDatagramReceived(handler: RefAction): void {
-        let ens = enums();
-        board().bus.listen(ens.MICROBIT_ID_RADIO, ens.MICROBIT_RADIO_EVT_DATAGRAM, handler);
-    }
 }
 
-namespace ks.rt.basic {
-    var board = micro_bit.board;
+namespace ks.rt.images {
+    export function createImage(img: Image) { return img }
+    export function createBigImage(img: Image) { return img }
+}
 
-    export var pause = thread.pause;
-
-    export function showNumber(x: number, interval: number) {
-        if (interval < 0) return;
-
-        let leds = micro_bit.createImageFromString(x.toString());
-        if (x < 0 || x >= 10) scrollImage(leds, interval, 1);
-        else showLeds(leds, interval * 5);
-    }
-
-    export function showString(s: string, interval: number) {
-        if (interval < 0) return;
-        if (s.length == 0) {
-            clearScreen();
-            pause(interval * 5);
-        } else {
-            let leds = micro_bit.createImageFromString(s);
-            if (s.length == 1) showLeds(leds, interval * 5)
-            else scrollImage(leds, interval, 1);
-        }
-    }
-
-    export function showLeds(leds: micro_bit.Image, delay: number): void {
-        showAnimation(leds, delay);
-    }
-
-    export function clearScreen() {
-        board().image.clear();
+namespace ks.rt.ImageMethods {
+    export function showImage(i: Image, offset: number) {
+        // TODO offset?
+        i.copyTo(0, 5, board().image, 0)
         runtime.queueDisplayUpdate()
     }
-
-    function scrollImage(leds: micro_bit.Image, interval: number, stride: number): void {
-        let cb = getResume()
-        let off = stride > 0 ? 0 : leds.width - 1;
-        let display = board().image;
-
-        board().animationQ.enqueue({
-            interval: interval,
-            frame: () => {
-                if (off >= leds.width || off < 0) return false;
-                stride > 0 ? display.shiftLeft(stride) : display.shiftRight(-stride);
-                let c = Math.min(stride, leds.width - off);
-                leds.copyTo(off, c, display, 5 - stride)
-                off += stride;
-                return true;
-            },
-            whenDone: cb
-        })
-    }
-
-    export function showAnimation(leds: micro_bit.Image, interval: number = 400): void {
-        scrollImage(leds, interval, 5);
-    }
-
-    export function forever(a: RefAction) {
-        function loop() {
-            runtime.runFiberAsync(a)
-                .then(() => Promise.delay(20))
-                .then(loop)
-                .done()
-        }
-        incr(a)
-        loop()
-    }
-}
-
-namespace ks.rt.control {
-    export var inBackground = thread.runInBackground;
-
-    export function reset() {
-        U.userError("reset not implemented in simulator yet")
-    }
+    
+    // TODO ...
 }

sim/simsvg.ts

@@ -188,10 +188,10 @@ namespace ks.rt.micro_bit {
         private thermometerText: SVGTextElement;
         private shakeButton: SVGCircleElement;
         private shakeText: SVGTextElement;
-        public board: rt.micro_bit.Board; 
+        public board: rt.Board; 
         
         constructor(public props: IBoardProps) {
-            this.board = this.props.runtime.board as rt.micro_bit.Board;
+            this.board = this.props.runtime.board as rt.Board;
             this.board.updateView = () => this.updateState();
             this.buildDom();              
             this.updateTheme();
@@ -227,7 +227,7 @@ namespace ks.rt.micro_bit {
                 Svg.fill(this.buttons[index], btn.pressed ? theme.buttonDown : theme.buttonUp);            
             });
             
-            var bw =  state.displayMode == rt.micro_bit.DisplayMode.bw         
+            var bw =  state.displayMode == rt.DisplayMode.bw         
             var img = state.image;
             this.leds.forEach((led,i) => {
                 var sel = (<SVGStylable><any>led)
@@ -261,8 +261,7 @@ namespace ks.rt.micro_bit {
                 this.shakeButton.addEventListener("mouseup", ev => {
                     let state = this.board;
                     Svg.fill(this.shakeButton, this.props.theme.virtualButtonUp);                              
-                    let ens = enums();
-                    this.board.bus.queue(ens.MICROBIT_ID_GESTURE, 11); // GESTURE_SHAKE
+                    this.board.bus.queue(DAL.MICROBIT_ID_GESTURE, 11); // GESTURE_SHAKE
                 })     
                 this.shakeText = Svg.child(this.g, "text", {x:400, y:110, class:'sim-text'}) as SVGTextElement;
                 this.shakeText.textContent = "SHAKE"     
@@ -782,8 +781,7 @@ svg.sim.grayscale {
                     let state = this.board;
                     state.pins[index].touched = false;
                     this.updatePin(state.pins[index], index);
-                    let ens = enums();
-                    this.board.bus.queue(state.pins[index].id, ens.MICROBIT_BUTTON_EVT_CLICK);
+                    this.board.bus.queue(state.pins[index].id, DAL.MICROBIT_BUTTON_EVT_CLICK);
                 })                
             })
             this.buttonsOuter.slice(0,2).forEach((btn, index) => {
@@ -802,8 +800,7 @@ svg.sim.grayscale {
                     state.buttons[index].pressed = false;
                     Svg.fill(this.buttons[index], this.props.theme.buttonUp);
                     
-                    let ens = enums();
-                    this.board.bus.queue(state.buttons[index].id, ens.MICROBIT_BUTTON_EVT_CLICK);
+                    this.board.bus.queue(state.buttons[index].id, DAL.MICROBIT_BUTTON_EVT_CLICK);
                 })
             })
             this.buttonsOuter[2].addEventListener("mousedown", ev => {
@@ -833,8 +830,7 @@ svg.sim.grayscale {
                     Svg.fill(this.buttons[1], this.props.theme.buttonUp);                
                     Svg.fill(this.buttons[2], this.props.theme.virtualButtonUp);                
                     
-                    let ens = enums();
-                    this.board.bus.queue(state.buttons[2].id, ens.MICROBIT_BUTTON_EVT_CLICK);
+                    this.board.bus.queue(state.buttons[2].id, DAL.MICROBIT_BUTTON_EVT_CLICK);
             })        
         }
     }

sim/state.ts

@@ -1,4 +1,4 @@
-namespace ks.rt.micro_bit {
+namespace ks.rt {
     export interface RuntimeOptions {
         theme: string;
     }
@@ -73,8 +73,7 @@ namespace ks.rt.micro_bit {
         queue(packet: PacketBuffer) {
             if (this.datagram.length < 5) {
                 this.datagram.push(packet);
-                let ens = enums();
-                (<Board>runtime.board).bus.queue(ens.MICROBIT_ID_RADIO, ens.MICROBIT_RADIO_EVT_DATAGRAM);
+                (<Board>runtime.board).bus.queue(DAL.MICROBIT_ID_RADIO, DAL.MICROBIT_RADIO_EVT_DATAGRAM);
             }
         }
 
@@ -114,10 +113,9 @@ namespace ks.rt.micro_bit {
         }
 
         broadcast(msg: number) {
-            let ens = enums();
             Runtime.postMessage(<SimulatorEventBusMessage>{
                 type: 'eventbus',
-                id: ens.MES_BROADCAST_GENERAL_ID,
+                id: DAL.MES_BROADCAST_GENERAL_ID,
                 eventid: msg,
                 power: this.power,
                 group: this.groupId
@@ -197,21 +195,21 @@ namespace ks.rt.micro_bit {
         private currentGesture: BasicGesture = BasicGesture.GESTURE_NONE;     // the instantaneous, unfiltered gesture detected.
         private sample: AccelerometerSample = { x: 0, y: 0, z: -1023 }
         private shake: ShakeHistory = { x: false, y: false, z: false, count: 0, shaken: 0, timer: 0 }; // State information needed to detect shake events.
-        private pitch:number;
-        private roll:number;
+        private pitch: number;
+        private roll: number;
         private id: number;
         public isActive = false;
         public sampleRange = 2;
 
         constructor(public runtime: Runtime) {
-            this.id = (<Enums><any>runtime.enums).MICROBIT_ID_ACCELEROMETER;
+            this.id = DAL.MICROBIT_ID_ACCELEROMETER;
         }
-        
-        public setSampleRange(range : number) {
+
+        public setSampleRange(range: number) {
             this.activate();
             this.sampleRange = Math.max(1, Math.min(8, range));
         }
-        
+
         public activate() {
             if (!this.isActive) {
                 this.isActive = true;
@@ -223,7 +221,7 @@ namespace ks.rt.micro_bit {
          * Reads the acceleration data from the accelerometer, and stores it in our buffer.
          * This is called by the tick() member function, if the interrupt is set!
          */
-        public update(x : number, y : number, z : number) {            
+        public update(x: number, y: number, z: number) {
             // read MSB values...
             this.sample.x = Math.floor(x);
             this.sample.y = Math.floor(y);
@@ -233,7 +231,7 @@ namespace ks.rt.micro_bit {
             this.updateGesture();
 
             // Indicate that a new sample is available
-            board().bus.queue(this.id, enums().MICROBIT_ACCELEROMETER_EVT_DATA_UPDATE)
+            board().bus.queue(this.id, DAL.MICROBIT_ACCELEROMETER_EVT_DATA_UPDATE)
         }
 
         public instantaneousAccelerationSquared() {
@@ -248,7 +246,6 @@ namespace ks.rt.micro_bit {
          * @return A best guess of the current posture of the device, based on instantaneous data.
          */
         private instantaneousPosture(): BasicGesture {
-            let ens = enums()
             let force = this.instantaneousAccelerationSquared();
             let shakeDetected = false;
 
@@ -258,25 +255,25 @@ namespace ks.rt.micro_bit {
             //
             // If we see enough zero crossings in succession (MICROBIT_ACCELEROMETER_SHAKE_COUNT_THRESHOLD), then we decide that the device
             // has been shaken.
-            if ((this.getX() < -ens.MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE && this.shake.x) || (this.getX() > ens.MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE && !this.shake.x)) {
+            if ((this.getX() < -DAL.MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE && this.shake.x) || (this.getX() > DAL.MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE && !this.shake.x)) {
                 shakeDetected = true;
                 this.shake.x = !this.shake.x;
             }
 
-            if ((this.getY() < -ens.MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE && this.shake.y) || (this.getY() > ens.MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE && !this.shake.y)) {
+            if ((this.getY() < -DAL.MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE && this.shake.y) || (this.getY() > DAL.MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE && !this.shake.y)) {
                 shakeDetected = true;
                 this.shake.y = !this.shake.y;
             }
 
-            if ((this.getZ() < -ens.MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE && this.shake.z) || (this.getZ() > ens.MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE && !this.shake.z)) {
+            if ((this.getZ() < -DAL.MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE && this.shake.z) || (this.getZ() > DAL.MICROBIT_ACCELEROMETER_SHAKE_TOLERANCE && !this.shake.z)) {
                 shakeDetected = true;
                 this.shake.z = !this.shake.z;
             }
 
-            if (shakeDetected && this.shake.count < ens.MICROBIT_ACCELEROMETER_SHAKE_COUNT_THRESHOLD && ++this.shake.count == ens.MICROBIT_ACCELEROMETER_SHAKE_COUNT_THRESHOLD)
+            if (shakeDetected && this.shake.count < DAL.MICROBIT_ACCELEROMETER_SHAKE_COUNT_THRESHOLD && ++this.shake.count == DAL.MICROBIT_ACCELEROMETER_SHAKE_COUNT_THRESHOLD)
                 this.shake.shaken = 1;
 
-            if (++this.shake.timer >= ens.MICROBIT_ACCELEROMETER_SHAKE_DAMPING) {
+            if (++this.shake.timer >= DAL.MICROBIT_ACCELEROMETER_SHAKE_DAMPING) {
                 this.shake.timer = 0;
                 if (this.shake.count > 0) {
                     if (--this.shake.count == 0)
@@ -287,48 +284,49 @@ namespace ks.rt.micro_bit {
             if (this.shake.shaken)
                 return BasicGesture.GESTURE_SHAKE;
 
-            if (force < ens.MICROBIT_ACCELEROMETER_FREEFALL_THRESHOLD)
+            let sq = (n: number) => n * n
+
+            if (force < sq(DAL.MICROBIT_ACCELEROMETER_FREEFALL_TOLERANCE))
                 return BasicGesture.GESTURE_FREEFALL;
 
-            if (force > ens.MICROBIT_ACCELEROMETER_3G_THRESHOLD)
+            if (force > sq(DAL.MICROBIT_ACCELEROMETER_3G_TOLERANCE))
                 return BasicGesture.GESTURE_3G;
 
-            if (force > ens.MICROBIT_ACCELEROMETER_6G_THRESHOLD)
+            if (force > sq(DAL.MICROBIT_ACCELEROMETER_6G_TOLERANCE))
                 return BasicGesture.GESTURE_6G;
 
-            if (force > ens.MICROBIT_ACCELEROMETER_8G_THRESHOLD)
+            if (force > sq(DAL.MICROBIT_ACCELEROMETER_8G_TOLERANCE))
                 return BasicGesture.GESTURE_8G;
 
             // Determine our posture.
-            if (this.getX() < (-1000 + ens.MICROBIT_ACCELEROMETER_TILT_TOLERANCE))
+            if (this.getX() < (-1000 + DAL.MICROBIT_ACCELEROMETER_TILT_TOLERANCE))
                 return BasicGesture.GESTURE_LEFT;
 
-            if (this.getX() > (1000 - ens.MICROBIT_ACCELEROMETER_TILT_TOLERANCE))
+            if (this.getX() > (1000 - DAL.MICROBIT_ACCELEROMETER_TILT_TOLERANCE))
                 return BasicGesture.GESTURE_RIGHT;
 
-            if (this.getY() < (-1000 + ens.MICROBIT_ACCELEROMETER_TILT_TOLERANCE))
+            if (this.getY() < (-1000 + DAL.MICROBIT_ACCELEROMETER_TILT_TOLERANCE))
                 return BasicGesture.GESTURE_DOWN;
 
-            if (this.getY() > (1000 - ens.MICROBIT_ACCELEROMETER_TILT_TOLERANCE))
+            if (this.getY() > (1000 - DAL.MICROBIT_ACCELEROMETER_TILT_TOLERANCE))
                 return BasicGesture.GESTURE_UP;
 
-            if (this.getZ() < (-1000 + ens.MICROBIT_ACCELEROMETER_TILT_TOLERANCE))
+            if (this.getZ() < (-1000 + DAL.MICROBIT_ACCELEROMETER_TILT_TOLERANCE))
                 return BasicGesture.GESTURE_FACE_UP;
 
-            if (this.getZ() > (1000 - ens.MICROBIT_ACCELEROMETER_TILT_TOLERANCE))
+            if (this.getZ() > (1000 - DAL.MICROBIT_ACCELEROMETER_TILT_TOLERANCE))
                 return BasicGesture.GESTURE_FACE_DOWN;
 
             return BasicGesture.GESTURE_NONE;
         }
 
         updateGesture() {
-            let ens = enums()
             // Determine what it looks like we're doing based on the latest sample...
             let g = this.instantaneousPosture();
 
             // Perform some low pass filtering to reduce jitter from any detected effects
             if (g == this.currentGesture) {
-                if (this.sigma < ens.MICROBIT_ACCELEROMETER_GESTURE_DAMPING)
+                if (this.sigma < DAL.MICROBIT_ACCELEROMETER_GESTURE_DAMPING)
                     this.sigma++;
             }
             else {
@@ -337,9 +335,9 @@ namespace ks.rt.micro_bit {
             }
 
             // If we've reached threshold, update our record and raise the relevant event...
-            if (this.currentGesture != this.lastGesture && this.sigma >= ens.MICROBIT_ACCELEROMETER_GESTURE_DAMPING) {
+            if (this.currentGesture != this.lastGesture && this.sigma >= DAL.MICROBIT_ACCELEROMETER_GESTURE_DAMPING) {
                 this.lastGesture = this.currentGesture;
-                board().bus.queue(ens.MICROBIT_ID_GESTURE, this.lastGesture);
+                board().bus.queue(DAL.MICROBIT_ID_GESTURE, this.lastGesture);
             }
         }
 
@@ -354,7 +352,7 @@ namespace ks.rt.micro_bit {
           * uBit.accelerometer.getX(RAW);
           * @endcode
           */
-        public getX(system : MicroBitCoordinateSystem = MicroBitCoordinateSystem.SIMPLE_CARTESIAN): number {
+        public getX(system: MicroBitCoordinateSystem = MicroBitCoordinateSystem.SIMPLE_CARTESIAN): number {
             this.activate();
             switch (system) {
                 case MicroBitCoordinateSystem.SIMPLE_CARTESIAN:
@@ -379,7 +377,7 @@ namespace ks.rt.micro_bit {
           * uBit.accelerometer.getY(RAW);
           * @endcode
           */
-        public getY(system : MicroBitCoordinateSystem = MicroBitCoordinateSystem.SIMPLE_CARTESIAN): number {
+        public getY(system: MicroBitCoordinateSystem = MicroBitCoordinateSystem.SIMPLE_CARTESIAN): number {
             this.activate();
             switch (system) {
                 case MicroBitCoordinateSystem.SIMPLE_CARTESIAN:
@@ -404,7 +402,7 @@ namespace ks.rt.micro_bit {
           * uBit.accelerometer.getZ(RAW);
           * @endcode
           */
-        public getZ(system : MicroBitCoordinateSystem = MicroBitCoordinateSystem.SIMPLE_CARTESIAN): number {
+        public getZ(system: MicroBitCoordinateSystem = MicroBitCoordinateSystem.SIMPLE_CARTESIAN): number {
             this.activate();
             switch (system) {
                 case MicroBitCoordinateSystem.NORTH_EAST_DOWN:
@@ -430,7 +428,7 @@ namespace ks.rt.micro_bit {
             return Math.floor((360 * this.getPitchRadians()) / (2 * Math.PI));
         }
 
-        getPitchRadians() : number {
+        getPitchRadians(): number {
             this.recalculatePitchRoll();
             return this.pitch;
         }
@@ -470,21 +468,6 @@ namespace ks.rt.micro_bit {
 
     }
 
-    export interface SimulatorEventBusMessage extends SimulatorMessage {
-        id: number;
-        eventid: number;
-        value?: number;
-    }
-
-    export interface SimulatorSerialMessage extends SimulatorMessage {
-        id: string;
-        data: string;
-    }
-
-    export interface SimulatorRadioPacketMessage extends SimulatorMessage {
-        data: number[];
-        rssi?: number;
-    }
 
     export class Board extends BaseBoard {
         id: string;
@@ -510,7 +493,7 @@ namespace ks.rt.micro_bit {
         serialIn: string[] = [];
 
         // sensors
-        accelerometer : Accelerometer;
+        accelerometer: Accelerometer;
 
         // gestures
         useShake = false;
@@ -533,34 +516,33 @@ namespace ks.rt.micro_bit {
             this.bus = new EventBus(runtime);
             this.radio = new RadioBus(runtime);
             this.accelerometer = new Accelerometer(runtime);
-            let ens = enums();
             this.buttons = [
-                new Button(ens.MICROBIT_ID_BUTTON_A),
-                new Button(ens.MICROBIT_ID_BUTTON_B),
-                new Button(ens.MICROBIT_ID_BUTTON_AB)
+                new Button(DAL.MICROBIT_ID_BUTTON_A),
+                new Button(DAL.MICROBIT_ID_BUTTON_B),
+                new Button(DAL.MICROBIT_ID_BUTTON_AB)
             ];
             this.pins = [
-                new Pin(ens.MICROBIT_ID_IO_P0),
-                new Pin(ens.MICROBIT_ID_IO_P1),
-                new Pin(ens.MICROBIT_ID_IO_P2),
-                new Pin(ens.MICROBIT_ID_IO_P3),
-                new Pin(ens.MICROBIT_ID_IO_P4),
-                new Pin(ens.MICROBIT_ID_IO_P5),
-                new Pin(ens.MICROBIT_ID_IO_P6),
-                new Pin(ens.MICROBIT_ID_IO_P7),
-                new Pin(ens.MICROBIT_ID_IO_P8),
-                new Pin(ens.MICROBIT_ID_IO_P9),
-                new Pin(ens.MICROBIT_ID_IO_P10),
-                new Pin(ens.MICROBIT_ID_IO_P11),
-                new Pin(ens.MICROBIT_ID_IO_P12),
-                new Pin(ens.MICROBIT_ID_IO_P13),
-                new Pin(ens.MICROBIT_ID_IO_P14),
-                new Pin(ens.MICROBIT_ID_IO_P15),
-                new Pin(ens.MICROBIT_ID_IO_P16),
+                new Pin(DAL.MICROBIT_ID_IO_P0),
+                new Pin(DAL.MICROBIT_ID_IO_P1),
+                new Pin(DAL.MICROBIT_ID_IO_P2),
+                new Pin(DAL.MICROBIT_ID_IO_P3),
+                new Pin(DAL.MICROBIT_ID_IO_P4),
+                new Pin(DAL.MICROBIT_ID_IO_P5),
+                new Pin(DAL.MICROBIT_ID_IO_P6),
+                new Pin(DAL.MICROBIT_ID_IO_P7),
+                new Pin(DAL.MICROBIT_ID_IO_P8),
+                new Pin(DAL.MICROBIT_ID_IO_P9),
+                new Pin(DAL.MICROBIT_ID_IO_P10),
+                new Pin(DAL.MICROBIT_ID_IO_P11),
+                new Pin(DAL.MICROBIT_ID_IO_P12),
+                new Pin(DAL.MICROBIT_ID_IO_P13),
+                new Pin(DAL.MICROBIT_ID_IO_P14),
+                new Pin(DAL.MICROBIT_ID_IO_P15),
+                new Pin(DAL.MICROBIT_ID_IO_P16),
                 null,
                 null,
-                new Pin(ens.MICROBIT_ID_IO_P19),
-                new Pin(ens.MICROBIT_ID_IO_P20)
+                new Pin(DAL.MICROBIT_ID_IO_P19),
+                new Pin(DAL.MICROBIT_ID_IO_P20)
             ];
         }