0.0.1

brick/README.md

@@ -11,8 +11,9 @@ they are derived from GPLv2 code).
 * the `d_usbdev` uses the composite framework to register an additional mass storage function in addtion
   to the pre-existing custom USB HID function
 * the `g_mass_storage` module has the following changes:
-  * a bug fixed, where page-misaligned writes would hang
   * additional `/sys/.../lun0/active` entry is added, which allows for signaling drive eject to the host
+* `d_usbdev` has an additional `ioctl()` to pretend data came from the USB host - this can be used to direct
+  the VM to do stuff
 
 ### Kernel modifications
 

brick/ins

@@ -5,6 +5,6 @@ cd /mnt/ramdisk/prjs/ko
 #echo 3 > /proc/sys/kernel/printk
 insmod ./nbd.ko
 sleep 1
-./uf2d > /tmp/uf2d.log 2> /tmp/uf2derr.log
+./uf2d /dev/nbd1 > /tmp/uf2d.log 2> /tmp/uf2derr.log
 sleep 1
-insmod ./d_usbdev.ko file=/dev/nbd0 HostStr=EV3 SerialStr=0016535543af
+insmod ./d_usbdev.ko file=/dev/nbd1 HostStr=EV3 SerialStr=0016535543af

brick/kernel/d_usbdev.c

@@ -543,12 +543,27 @@ static int Device1Mmap(struct file *filp, struct vm_area_struct *vma)
 
    return (ret);
 }
+
+#define FEED_DATA _IOC(_IOC_WRITE, 't', 108, 1024)
+
+static int Device1Ioctl(struct inode *pNode, struct file *File, unsigned int Request, unsigned long Pointer)
+{
+  if (Request != FEED_DATA)
+    return -EINVAL;
+
+  copy_from_user(usb_char_buffer_out,(void*)Pointer,1024);
+  usb_char_out_length = 1024;
+
+  return 0;
+}
+
 static    const struct file_operations Device1Entries =
 {
   .owner        = THIS_MODULE,
   .read         = Device1Read,
   .write        = Device1Write,
-  .mmap         = Device1Mmap
+  .mmap         = Device1Mmap,
+  .ioctl        = Device1Ioctl
 };
 
 

brick/kernel/f_mass_storage.c

@@ -2410,7 +2410,28 @@ static void fsg_disable(struct usb_function *f)
 	fsg->common->prev_fsg = fsg->common->fsg;
 	fsg->common->fsg = fsg;
 	fsg->common->new_config = 0;
-	raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
+
+	DBG(common, "fsg_disable filp=%p\n", fsg->common->luns[0].filp);
+	raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE_DISABLE);
+}
+
+static void shutdown_server(void) {
+	DBG(fsg_common, "shutdown_server filp=%p\n", fsg_common->luns[0].filp);
+	if (fsg_common->luns[0].filp) {
+		uint32_t buf[512 / 4];
+		loff_t file_offset_tmp = 512 * 50000; // make sure we're outside of FS area
+		int i;
+
+		// this should shut down the nbd server, so that the caches are flushed
+		memset(buf, 0, sizeof(buf));
+		buf[0] = 0x20da6d81;
+		buf[1] = 0x747e09d4;
+
+		fsg_common->luns[0].filp->f_flags |= O_SYNC;
+		for (i = 0; i < 2; ++i)
+			vfs_write(fsg_common->luns[0].filp,
+							(char*)buf, 512, &file_offset_tmp);
+	}
 }
 
 
@@ -2532,6 +2553,9 @@ static void handle_exception(struct fsg_common *common)
 		/*		SS_RESET_OCCURRED;  */
 		break;
 
+	case FSG_STATE_CONFIG_CHANGE_DISABLE:
+		shutdown_server();
+		// fall-through
 	case FSG_STATE_CONFIG_CHANGE:
 		rc = do_set_config(common, new_config);
 		if (common->ep0_req_tag != exception_req_tag)

brick/kernel/storage_common.c

@@ -334,6 +334,7 @@ enum fsg_state {
 	FSG_STATE_ABORT_BULK_OUT,
 	FSG_STATE_RESET,
 	FSG_STATE_INTERFACE_CHANGE,
+	FSG_STATE_CONFIG_CHANGE_DISABLE,
 	FSG_STATE_CONFIG_CHANGE,
 	FSG_STATE_DISCONNECT,
 	FSG_STATE_EXIT,

brick/scripts/README.md

@@ -0,0 +1,14 @@
+# Patched EV3 image
+
+The file `ev3-fs.patch` summarizes the changes done to the original V1.09D image.
+You can see some text files are edited, the `d_usbdev.ko` is updated (sources in `../kernel`),
+`uf2d` added (sources in `../uf2daemon`), and a stock `nbd.ko` module is added.
+
+Additionally, the `edimax01.ko` is replaced by now much more popular `rtl8192cu.ko` (also stock).
+
+The init script has a hook for running a shell script from `/mnt/ramdisk/`. This can be used
+for testing different modules etc.
+
+The kernel command line has been modified to:
+* disable DMA for the MUSB driver - otherwise the mass storage device is very unstable
+* increase the size of dmesg buffer to 128k

brick/scripts/ev3-fs.patch

@@ -0,0 +1,53 @@
+diff -ur orig-ev3/etc/init.d/ev3init.sh dev-ev3/etc/init.d/ev3init.sh
+--- orig-ev3/etc/init.d/ev3init.sh	1970-01-01 01:00:00.000000000 +0100
++++ dev-ev3/etc/init.d/ev3init.sh	2017-07-27 12:19:43.195041798 +0100
+@@ -1,5 +1,7 @@
+ #!/bin/sh
+ 
++echo Y > /sys/module/printk/parameters/time
++
+ bluetoothd -n > /dev/null 2>&1 &
+ 
+ echo "Setting up VirtualDrive...";
+@@ -60,3 +62,6 @@
+ sleep 2
+ hciattach /dev/ttyS2 texas 2000000 "flow" "nosleep" $STRING
+ sdptool add SP
++
++insmod /lib/modules/2.6.33-rc4/kernel/drivers/net/wireless/rtl8192cu.ko
++. /mnt/ramdisk/rc.local || :
+Only in orig-ev3/home/root/lms2012/sys: exit~
+diff -ur orig-ev3/home/root/lms2012/sys/init dev-ev3/home/root/lms2012/sys/init
+--- orig-ev3/home/root/lms2012/sys/init	1970-01-01 01:00:00.000000000 +0100
++++ dev-ev3/home/root/lms2012/sys/init	2017-07-27 12:23:43.072605126 +0100
+@@ -5,13 +5,15 @@
+ var=$(printf 'HostStr=%s SerialStr=%s' $(cat /home/root/lms2012/sys/settings/BrickName) $(cat /home/root/lms2012/sys/settings/BTser))
+ echo $var > /home/root/lms2012/sys/settings/UsbInfo.dat
+ 
++insmod ${PWD}/mod/nbd.ko
++${PWD}/uf2d
+ insmod ${PWD}/mod/d_iic.ko `cat /home/root/lms2012/sys/settings/HwId`
+ insmod ${PWD}/mod/d_uart.ko `cat /home/root/lms2012/sys/settings/HwId`
+ insmod ${PWD}/mod/d_power.ko `cat /home/root/lms2012/sys/settings/HwId`
+ insmod ${PWD}/mod/d_pwm.ko `cat /home/root/lms2012/sys/settings/HwId`
+ insmod ${PWD}/mod/d_ui.ko `cat /home/root/lms2012/sys/settings/HwId`
+ insmod ${PWD}/mod/d_analog.ko `cat /home/root/lms2012/sys/settings/HwId`
+-insmod ${PWD}/mod/d_usbdev.ko `cat /home/root/lms2012/sys/settings/UsbInfo.dat`
++insmod ${PWD}/mod/d_usbdev.ko `cat /home/root/lms2012/sys/settings/UsbInfo.dat` file=/dev/nbd0
+ insmod ${PWD}/mod/d_usbhost.ko
+ insmod ${PWD}/mod/d_sound.ko `cat /home/root/lms2012/sys/settings/HwId`
+ insmod ${PWD}/mod/d_bt.ko `cat /home/root/lms2012/sys/settings/HwId`
+@@ -29,6 +31,8 @@
+ chmod 666 /dev/lms_iic
+ chmod 666 /dev/lms_bt
+ 
++echo 4 > /proc/sys/kernel/printk
++ 
+ cd ..
+ ls -R > /dev/null
+ cd sys
+Binary files orig-ev3/home/root/lms2012/sys/mod/d_usbdev.ko and dev-ev3/home/root/lms2012/sys/mod/d_usbdev.ko differ
+Only in dev-ev3/home/root/lms2012/sys/mod: nbd.ko
+Only in dev-ev3/home/root/lms2012/sys: uf2d
+Only in orig-ev3/lib/modules/2.6.33-rc4/kernel/drivers/net/wireless: edimax01.ko
+Only in dev-ev3/lib/modules/2.6.33-rc4/kernel/drivers/net/wireless: rtl8192cu.ko

brick/scripts/img.js

@@ -1,14 +1,36 @@
 #!/bin/sh
 
 let fs = require("fs")
+// we try to use shorter versions of all parameters for the additional parameters to fit
+let bootargs = "mem=${memsize} initrd=${filesysaddr},${filesyssize} root=/dev/ram0 rw rootfstype=cramfs console=${console} ip=${ipaddr} lpj=747520 quiet"
+let bootnews = "mem=64M initrd=0xC1180000,10M root=1:0 rw rootfstype=cramfs console=${console} lpj=747520 musb_hdrc.use_dma=0 log_buf_len=128k quiet"
+let piggy = true
 
 function build() {
-  let cr = fs.readFileSync("cram.bin")
-  if (cr.length > 10878976) {
-    console.log("too big")
+  if (bootnews.length > bootargs.length) {
+    console.log("args too long")
     return
   }
-  let img = fs.readFileSync("boot.bin")
+
+  while (bootnews.length < bootargs.length)
+    bootnews += " "
+
+  let cr = fs.readFileSync("cram.bin")
+
+  if (cr.length > 10485760) {
+    console.log("too big by " + (cr.length - 10485760))
+    return
+  }
+  let img = fs.readFileSync("EV3 Firmware V1.09D.bin")
+
+  for (let i = 0; i < bootnews.length; ++i) {
+    if (img[0x21DDA + i] != bootargs.charCodeAt(i)) {
+      console.log("boot args mismatch")
+      return 
+    }
+    img[0x21DDA + i] = bootnews.charCodeAt(i)
+  }
+  
   let off = 0x250000
   if (img[off] != 0x45 || img[off + 1] != 0x3d) {
     console.log("bad magic: " + img[off] + " / " + img[off+1])
@@ -17,8 +39,8 @@ function build() {
 
   cr.copy(img, off)
 
-  let kern = fs.readFileSync("piggy-patched.gzip")
-  off = 0x0005540f
+  let kern = fs.readFileSync(piggy ? "piggy-patched.gzip" : "linux/arch/arm/boot/uImage")
+  off = piggy ? 0x0005540f : 0x00050000
 
   if (img[off] != kern[0] || img[off+1] != kern[1]) {
     console.log("bad kernel magic: " + img[off] + " / " + img[off+1])

brick/scripts/mkimg

@@ -1,4 +1,9 @@
 #!/bin/sh
+# dd if=EV3\ Firmware\ V1.09D.bin of=orig.cram bs=65536 skip=37 count=400
+
+sudo cp linux/pxt/uf2daemon/server dev-ev3/home/root/lms2012/sys/uf2d
+sudo cp linux/pxt/kernel/d_usbdev.ko dev-ev3/home/root/lms2012/sys/mod/d_usbdev.ko
+sudo chown -R root:root dev-ev3/home/root/lms2012
 sudo mkfs.cramfs dev-ev3 cram.bin
 node img
 ls -l firmware.bin

brick/uf2daemon/fat.c

@@ -19,6 +19,9 @@
 #include <time.h>
 #include <signal.h>
 #include <sys/wait.h>
+#include <sys/ioctl.h>
+#include <string.h>
+#include <errno.h>
 
 #define max(a, b)                                                                                  \
     ({                                                                                             \
@@ -627,6 +630,48 @@ void read_block(uint32_t block_no, uint8_t *data) {
     }
 }
 
+char rbfPath[300];
+
+uint8_t stopApp[] = {
+    0x05, 0x00, // size
+    0x00, 0x00, // seq. no.
+    0x3f, 0x3d, // usb magic,
+    0x02,       // req. no.
+};
+
+uint8_t runStart[] = {0x00, 0x00,       // size
+                      0x00, 0x00,       // seq. no.
+                      0x00, 0x00, 0x08, // something
+                      0xC0, 0x08, 0x82, 0x01, 0x00, 0x84};
+
+uint8_t runEnd[] = {0x00, 0x60, 0x64, 0x03, 0x01, 0x60, 0x64, 0x00};
+
+#define FEED_DATA _IOC(_IOC_WRITE, 't', 108, 1024)
+
+void startRbf() {
+    char buf[1024];
+    memset(buf, 0, sizeof(buf));
+    memcpy(buf, stopApp, sizeof(stopApp));
+
+    int fd = open("/dev/lms_usbdev", O_RDWR);
+    ioctl(fd, FEED_DATA, buf);
+    usleep(500000);
+
+    int off = 0;
+    memcpy(buf + off, runStart, sizeof(runStart));
+    off += sizeof(runStart);
+    strcpy(buf + off, rbfPath);
+    off += strlen(rbfPath);
+    memcpy(buf + off, runEnd, sizeof(runEnd));
+    off += sizeof(runEnd);
+    off -= 2;
+    buf[0] = off & 0xff;
+    buf[1] = off >> 8;
+    ioctl(fd, FEED_DATA, buf);
+
+    close(fd);
+}
+
 #define MAX_BLOCKS 8000
 typedef struct {
     uint32_t numBlocks;
@@ -634,81 +679,30 @@ typedef struct {
     uint8_t writtenMask[MAX_BLOCKS / 8 + 1];
 } WriteState;
 
-char elfPath[300];
-
-int lmsPid;
-void stopLMS() {
-    struct dirent *ent;
-    DIR *dir;
-
-    dir = opendir("/proc");
-    if (dir == NULL)
-        return;
-
-    while ((ent = readdir(dir)) != NULL) {
-        int pid = atoi(ent->d_name);
-        if (!pid)
-            continue;
-        char namebuf[100];
-        snprintf(namebuf, 1000, "/proc/%d/cmdline", pid);
-        FILE *f = fopen(namebuf, "r");
-        if (f) {
-            fread(namebuf, 1, 99, f);
-            if (strcmp(namebuf, "./lms2012") == 0) {
-                lmsPid = pid;
-            }
-            fclose(f);
-            if (lmsPid)
-                break;
-        }
-    }
-
-    closedir(dir);
-
-    if (lmsPid) {
-        DBG("SIGSTOP to lmsPID=%d", lmsPid);
-        kill(lmsPid, SIGSTOP);
-    } else {
-        DBG("LMS not found");
-    }
-}
-
-void waitAndContinue() {
-    stopLMS();
-    for (int fd = 3; fd < 9999; ++fd)
-        close(fd);
-    pid_t child = fork();
-    if (child == 0) {
-        DBG("start %s", elfPath);
-        execl(elfPath, elfPath, "--msd", (char *)NULL);
-        exit(128);
-    }
-    int status;
-    waitpid(child, &status, 0);
-    DBG("re-start LMS");
-    if (lmsPid) {
-        kill(lmsPid, SIGCONT);
-    }
-    exit(0);
-}
-
 void restartProgram() {
-    if (!elfPath[0])
+    if (!rbfPath[0])
         exit(0);
-
-    pid_t child = fork();
-    if (child == 0)
-        waitAndContinue();
-    else
-        exit(0); // causes parent to eject MSD etc
+    startRbf();
+    exit(0); // causes parent to eject MSD etc
 }
 
+int numWrites = 0;
 static WriteState wrState;
 void write_block(uint32_t block_no, uint8_t *data) {
     WriteState *state = &wrState;
 
     UF2_Block *bl = (void *)data;
 
+    if (bl->magicStart0 == 0x20da6d81 && bl->magicStart1 == 0x747e09d4) {
+        DBG("restart req, #wr=%d", numWrites);
+        if (numWrites) {
+            exit(0);
+        }
+        return;
+    }
+
+    numWrites++;
+
     if (!is_uf2_block(bl)) {
         return;
     }
@@ -747,6 +741,10 @@ void write_block(uint32_t block_no, uint8_t *data) {
         *p = '/';
 
         int fd = open(fn, O_WRONLY | O_CREAT, 0777);
+        if (fd < 0 && errno == ETXTBSY) {
+            unlink(fn);
+            fd = open(fn, O_WRONLY | O_CREAT, 0777);
+        }
         if (fd >= 0) {
             ftruncate(fd, bl->fileSize);
             lseek(fd, bl->targetAddr, SEEK_SET);
@@ -754,8 +752,8 @@ void write_block(uint32_t block_no, uint8_t *data) {
             write(fd, bl->data, bl->payloadSize);
             close(fd);
 
-            if (strlen(fn) > 4 && !strcmp(fn + strlen(fn) - 4, ".elf")) {
-                strcpy(elfPath, fn);
+            if (strlen(fn) > 4 && !strcmp(fn + strlen(fn) - 4, ".rbf")) {
+                strcpy(rbfPath, fn);
             }
         }
     }

brick/uf2daemon/main.c

@@ -20,6 +20,9 @@
 
 #include "uf2.h"
 
+const char *dev_file = "/dev/nbd0";
+
+
 #define NUM_BLOCKS NUM_FAT_BLOCKS
 
 uint64_t ntohll(uint64_t a) {
@@ -29,23 +32,30 @@ uint64_t ntohll(uint64_t a) {
 
 void mylog(const char *fmt, ...) {
     va_list args;
-    char *p;
+    char *p, *p2;
 
     va_start(args, fmt);
     vasprintf(&p, fmt, args);
     vprintf(fmt, args);
     va_end(args);
 
-    int len = strlen(p) + 1;
-    p[len - 1] = '\n';
+    if (p[0] != '<')
+        asprintf(&p2, "<6>%s\n", p);
+    else
+        asprintf(&p2, "%s\n", p);
+
+    int len = strlen(p2);
 
 #ifdef X86
-    write(2, p, len);
+    write(2, p2, len);
 #else
     int fd = open("/dev/kmsg", O_WRONLY);
-    write(fd, p, len);
+    write(fd, p2, len);
     close(fd);
 #endif
+
+    free(p);
+    free(p2);
 }
 
 void readAll(int fd, void *dst, uint32_t length) {
@@ -89,8 +99,6 @@ void startclient() {
     exit(0);
 }
 
-#define dev_file "/dev/nbd0"
-
 void handleread(int off, int len) {
     uint8_t buf[512];
     LOG("read @%d len=%d", off, len);
@@ -189,11 +197,14 @@ void enableMSD(int enabled) {
 #endif
 }
 
-int main() {
+int main(int argc, char **argv) {
 #ifndef X86
     daemon(0, 1);
 #endif
 
+    if (argc > 1)
+        dev_file = argv[1];
+
     for (;;) {
         pid_t child = fork();
         if (child == 0) {

brick/uf2daemon/uf2.h

@@ -37,7 +37,7 @@ void mylog(const char *fmt, ...);
 
 #define FAIL(args...)                                                                              \
     do {                                                                                           \
-        mylog(args);                                                                                 \
+        mylog("<4>" args);                                                                                 \
         exit(1);                                                                                   \
     } while (0)
 

editor/extension.ts

@@ -41,7 +41,8 @@ namespace pxt.editor {
     export function deployCoreAsync(resp: pxtc.CompileResult, isCli = false) {
         let w: Ev3Wrapper
 
-        let filename = resp.downloadFileBaseName
+        let filename = resp.downloadFileBaseName || "pxt"
+        filename = filename.replace(/^lego-/, "")
 
         let fspath = "../prjs/BrkProg_SAVE/"
 

libs/base/enums.d.ts

@@ -30,7 +30,5 @@
     Object = 4,
     Function = 5,
     }
-declare namespace serial {
-}
 
 // Auto-generated. Do not edit. Really.

libs/base/shims.d.ts

@@ -0,0 +1,158 @@
+// Auto-generated. Do not edit.
+
+
+
+    //% 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: int32, value: number): void;
+
+    /**
+     * Read a number in specified format from the buffer.
+     */
+    //% shim=BufferMethods::getNumber
+    getNumber(format: NumberFormat, offset: int32): number;
+
+    /** Returns the length of a Buffer object. */
+    //% property shim=BufferMethods::length
+    length: int32;
+
+    /**
+     * Fill (a fragment) of the buffer with given value.
+     */
+    //% offset.defl=0 length.defl=-1 shim=BufferMethods::fill
+    fill(value: int32, offset?: int32, length?: int32): void;
+
+    /**
+     * Return a copy of a fragment of a buffer.
+     */
+    //% offset.defl=0 length.defl=-1 shim=BufferMethods::slice
+    slice(offset?: int32, length?: int32): Buffer;
+
+    /**
+     * Shift buffer left in place, with zero padding.
+     * @param offset number of bytes to shift; use negative value to shift right
+     * @param start start offset in buffer. Default is 0.
+     * @param length number of elements in buffer. If negative, length is set as the buffer length minus
+     * start. eg: -1
+     */
+    //% start.defl=0 length.defl=-1 shim=BufferMethods::shift
+    shift(offset: int32, start?: int32, length?: int32): void;
+
+    /**
+     * Convert a buffer to its hexadecimal representation.
+     */
+    //% shim=BufferMethods::toHex
+    toHex(): string;
+
+    /**
+     * Rotate buffer left in place.
+     * @param offset number of bytes to shift; use negative value to shift right
+     * @param start start offset in buffer. Default is 0.
+     * @param length number of elements in buffer. If negative, length is set as the buffer length minus
+     * start. eg: -1
+     */
+    //% start.defl=0 length.defl=-1 shim=BufferMethods::rotate
+    rotate(offset: int32, start?: int32, length?: int32): void;
+
+    /**
+     * Write contents of `src` at `dstOffset` in current buffer.
+     */
+    //% shim=BufferMethods::write
+    write(dstOffset: int32, src: Buffer): void;
+}
+declare namespace loops {
+
+    /**
+     * Repeats the code forever in the background. On each iteration, allows other codes to run.
+     * @param body code to execute
+     */
+    //% help=loops/forever weight=100 blockGap=8
+    //% blockId=forever block="forever" blockAllowMultiple=1 shim=loops::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=loops/pause weight=99
+    //% async block="pause (ms) %pause"
+    //% blockId=device_pause shim=loops::pause
+    function pause(ms: int32): void;
+}
+declare namespace control {
+
+    /**
+     * Gets the number of milliseconds elapsed since power on.
+     */
+    //% help=control/millis weight=50
+    //% blockId=control_running_time block="millis (ms)" shim=control::millis
+    function millis(): int32;
+
+    /**
+     * Run code when a registered event happens.
+     * @param id the event compoent id
+     * @param value the event value to match
+     */
+    //% weight=20 blockGap=8 blockId="control_on_event" block="on event|from %src|with value %value"
+    //% blockExternalInputs=1
+    //% help="control/on-event" shim=control::onEvent
+    function onEvent(src: int32, value: int32, handler: () => void): void;
+
+    /**
+     * Reset the device.
+     */
+    //% weight=30 async help=control/reset blockGap=8
+    //% blockId="control_reset" block="reset" shim=control::reset
+    function reset(): void;
+
+    /**
+     * Block the current fiber for the given microseconds
+     * @param micros number of micro-seconds to wait. eg: 4
+     */
+    //% help=control/wait-micros weight=29 async
+    //% blockId="control_wait_us" block="wait (µs)%micros" shim=control::waitMicros
+    function waitMicros(micros: int32): void;
+
+    /**
+     * Run other code in the background.
+     */
+    //% help=control/run-in-background blockAllowMultiple=1
+    //% blockId="control_run_in_background" block="run in background" blockGap=8 shim=control::runInBackground
+    function runInBackground(a: () => void): void;
+
+    /**
+     * Blocks the calling thread until the specified event is raised.
+     */
+    //% help=control/wait-for-event async
+    //% blockId=control_wait_for_event block="wait for event|from %src|with value %value" shim=control::waitForEvent
+    function waitForEvent(src: int32, value: int32): void;
+
+    /**
+     * Derive a unique, consistent serial number of this device from internal data.
+     */
+    //% blockId="control_device_serial_number" block="device serial number" weight=9 shim=control::deviceSerialNumber
+    function deviceSerialNumber(): int32;
+}
+declare namespace serial {
+
+    /**
+     * Write some text to the serial port.
+     */
+    //% help=serial/write-string
+    //% weight=87
+    //% blockId=serial_writestring block="serial|write string %text" shim=serial::writeString
+    function writeString(text: string): void;
+
+    /**
+     * Send a buffer across the serial connection.
+     */
+    //% help=serial/write-buffer advanced=true weight=6
+    //% blockId=serial_writebuffer block="serial|write buffer %buffer" shim=serial::writeBuffer
+    function writeBuffer(buffer: Buffer): void;
+}
+
+// Auto-generated. Do not edit. Really.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "pxt-ev3",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "description": "LEGO Mindstorms EV3 for Microsoft MakeCode",
   "private": true,
   "keywords": [
@@ -39,8 +39,8 @@
     "semantic-ui-less": "^2.2.4"
   },
   "dependencies": {
-    "pxt-common-packages": "0.8.1",
-    "pxt-core": "1.7.4"
+    "pxt-common-packages": "0.9.1",
+    "pxt-core": "1.8.10"
   },
   "scripts": {
     "test": "node node_modules/pxt-core/built/pxt.js travis"