1.1.14

* disable drift correction by default

* disable drift correction

* better calibration sequence

* add comments

* updated comment about beta

.travis.yml

@@ -0,0 +1,9 @@
+language: node_js
+node_js:
+  - "8.9.0"
+script:
+  - "node node_modules/pxt-core/built/pxt.js travis"
+sudo: false
+cache:
+  directories:
+    - node_modules

README.md

@@ -1,13 +1,8 @@
-# LEGO® MINDSTORMS® Education EV3 for Microsoft MakeCode
-
-[![Build Status](https://ci2.dot.net/buildStatus/icon?job=Private/pxt_project_rainbow/master/pxt-ev3_Push)](https://ci2.dot.net/job/Private/job/pxt_project_rainbow/job/master/job/pxt-ev3_Push/)
+# LEGO® MINDSTORMS® Education EV3 for Microsoft MakeCode [![Build Status](https://travis-ci.org/microsoft/pxt-ev3.svg?branch=master)](https://travis-ci.org/microsoft/pxt-ev3)
 
 This repo contains the editor target hosted at https://makecode.mindstorms.com
 
-LEGO Auth: https://src.education.lego.com/groups/ev3-makecode (use Google Authenticator)
-LEGO Chat: https://chat.internal.education.lego.com/make-code/channels/town-square
-
-## Local Dev setup
+## Local setup
 
 These instructions assume familiarity with dev tools and languages.
 
@@ -15,10 +10,6 @@ These instructions assume familiarity with dev tools and languages.
 * install Docker; make sure `docker` command is in your `PATH`
 * (optional) install [Visual Studio Code](https://code.visualstudio.com/)
 
-In a common folder,
-
-* clone https://github.com/Microsoft/pxt to ``pxt`` folder
-* clone https://github.com/Microsoft/pxt-common-packages to ``pxt-common-packages`` folder
 * clone https://github.com/Microsoft/pxt-ev3 to ``pxt-ev3`` folder
 * go to ``pxt`` and run
 
@@ -26,6 +17,18 @@ In a common folder,
 npm install
 ```
 
+* to run the local server,
+```
+pxt serve --cloud
+```
+
+## Local Dev setup
+
+In the common folder,
+
+* clone https://github.com/Microsoft/pxt to ``pxt`` folder
+* clone https://github.com/Microsoft/pxt-common-packages to ``pxt-common-packages`` folder
+
 * go to ``pxt-common-packages`` and run
 
 ```
@@ -57,12 +60,12 @@ cd libs/core
 pxt deploy
 ```
 
-### Jenkins build
-https://ci2.dot.net/job/Private/job/pxt_project_rainbow/job/master/
-
 ## License
 MIT
 
+## Trademarks
+MICROSOFT, the Microsoft Logo, and MAKECODE are registered trademarks of Microsoft Corporation. They can only be used for the purposes described in and in accordance with Microsoft’s Trademark and Brand guidelines published at https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general.aspx. If the use is not covered in Microsoft’s published guidelines or you are not sure, please consult your legal counsel or the MakeCode team (makecode@microsoft.com). 
+
 ## Code of Conduct
 
 This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

docs/coding/line-detection.md

@@ -190,12 +190,10 @@ if (true) {
 
 ```blocks
 forever(function () {
-    while (true) {
-        sensors.color3.pauseUntilColorDetected(ColorSensorColor.Black)
+    while (sensors.color3.color() == ColorSensorColor.Black) {
         motors.largeBC.steer(-30, 50)
     }
-    while (true) {
-        sensors.color3.pauseUntilColorDetected(ColorSensorColor.White)
+    while (sensors.color3.color() == ColorSensorColor.White) {
         motors.largeBC.steer(30, 50)
     }
 })
@@ -209,11 +207,9 @@ Else the Color Sensor detects the color white, start motors ``B`` and ``C`` (dri
 
 ```blocks
 forever(function () {
-    if (true) {
-        sensors.color3.pauseUntilColorDetected(ColorSensorColor.Black)
+    if (sensors.color3.color() == ColorSensorColor.Black) {
         motors.largeBC.steer(-30, 50)
     } else {
-        sensors.color3.pauseUntilColorDetected(ColorSensorColor.White)
         motors.largeBC.steer(30, 50)
     }
 })

docs/design-engineering/make-it-smarter.md

@@ -101,9 +101,9 @@ The blocks inside the ``||loops:forever||`` loop have these actions:
 1. Turn on the ``green`` EV3 Brick Status Light.
 2. Wait for Ultrasonic Sensor to detect an object.
 3. Turn on Motors ``A`` and ``D`` in opposite directions.
-4. Wait for one quarter of a second (``1500`` milli seconds).
+4. Wait for one and a half seconds (``1500`` milli seconds).
 5. Reverse the direction of Motors ``A`` and ``D``.
-6. Wait for one quarter of a second.
+6. Wait for one and a half seconds.
 7. Stop all motors.
 8. Make an insect chirping sound.
 9. Loop continuously so that the insect wanders around when the Ultrasonic Sensor is detects something.

docs/extensions.md

@@ -0,0 +1,18 @@
+# Extensions
+
+## #gallery
+
+## Using Extensions
+
+In the web editor, click on ``Settings`` then ``Extensions`` to search and add extensions to the project.
+The Blocks and JavaScript definitions will be automatically loaded in the editor.
+
+## Custom extensions
+
+The [Build Your Own Extension](https://makecode.com/extensions/getting-started) manual is for advanced users who want to publish their own extension. 
+
+## ~ hint
+
+**Extensions** were previously called **Packages** in MakeCode.
+
+## ~

docs/fll.md

@@ -6,6 +6,10 @@ For teams participating in the Open Software Platform Pilot utilizing MakeCode,
 
 ## FAQ
 
+### I found a bug what do I do?
+
+If you found a bug, please try if it hasn't been fixed yet! Go to https://makecode.mindstorms.com/beta and try if the bug is corrected. Otherwise, please open an issue at https://github.com/microsoft/pxt-ev3/issues.
+
 ### How do I use MakeCode with my EV3?
 
 * You will need to install the latest EV3 firmware on your brick. Instructions on how to do that are located here: https://makecode.mindstorms.com/troubleshoot.

docs/index-ref.json

@@ -1,3 +1,3 @@
 {
-    "appref": "v1.0.8"
+    "appref": "v1.0.11"
 }

docs/offline-app.html

@@ -388,12 +388,12 @@
         }
         function downloadWin64() {
             // TODO: Keep this link up-to-date with the desired release version
-            window.open("https://makecode.com/api/release/ev3/v1.0.8/win64");
+            window.open("https://makecode.com/api/release/ev3/v1.0.11/win64");
             tickEvent("offlineapp.download", { "target": "ev3", "platform": "win64" });
         }
         function downloadMac64() {
             // TODO: Keep this link up-to-date with the desired release version
-            window.open("https://makecode.com/api/release/ev3/v1.0.8/mac64");
+            window.open("https://makecode.com/api/release/ev3/v1.0.11/mac64");
             tickEvent("offlineapp.download", { "target": "ev3", "platform": "mac64" });
         }
     </script>

docs/offline.md

@@ -0,0 +1,11 @@
+# @extends
+
+## Offline app #target-app
+
+The MakeCode editor is available as app which you can install on a computer with Windows or Mac OS. Once installed, the **[MakeCode Offline App](/offline-app)** lets you create, run, and download your projects to the @boardname@. It works the same as the Web application does in your browser but it's a stand-alone application that will work when a connection to the internet is restricted or not available.
+
+### ~ hint
+
+The [MakeCode Offline App](/offline-app) is currently in development and is made available as a **pre-release** version. 
+
+### ~

docs/packages-ref.json

@@ -0,0 +1,3 @@
+{
+    "redirect": "/extensions"
+}

docs/packages/approval-ref.json

@@ -0,0 +1,3 @@
+{
+    "redirect": "https://makecode.com/extensions/approval"
+}

docs/packages/build-your-own-ref.json

@@ -0,0 +1,3 @@
+{
+    "redirect": "https://makecode.com/extensions/getting-started"
+}

docs/packages/versioning-ref.json

@@ -0,0 +1,3 @@
+{
+    "redirect": "https://makecode.com/extensions/versioning"
+}

docs/reference/motors/synced/steer.md

@@ -39,6 +39,13 @@ motors.largeBC.steer(-15, -75)
 
 ## ~
 
+## ~ hint
+
+Only one set of synchronized motors will run at the same time. Once you launch tank/steer, it will cancel any existing synchronized speed command.
+
+## ~
+
+
 ## Examples
 
 ### Make a slight right
@@ -79,6 +86,51 @@ for (let i = 0; i < 4; i++) {
 motors.stopAll()
 ```
 
+### Steer tester
+
+This program lets you change the values of speed and turn ratio with the buttons.
+
+```typescript
+let speed = 0;
+let turnRatio = 0;
+
+brick.showString(`steer tester`, 1)
+brick.showString(`connect motors BC`, 7)
+brick.showString(`up/down for speed`, 8)
+brick.showString(`left/right for turn ratio`, 9)
+
+forever(function () {
+    brick.showString(`motor B speed ${motors.largeB.speed()}%`, 4)
+    brick.showString(`motor C speed ${motors.largeC.speed()}%`, 5)
+    pause(100)
+})
+
+function updateSteer() {
+    motors.largeBC.steer(turnRatio, speed);
+    brick.showString(`speed ${speed}%`, 2)
+    brick.showString(`turnRatio ${turnRatio}`, 3)
+}
+
+brick.buttonUp.onEvent(ButtonEvent.Pressed, function () {
+    speed += 10
+    updateSteer()
+})
+brick.buttonDown.onEvent(ButtonEvent.Pressed, function () {
+    speed -= 10
+    updateSteer()
+})
+brick.buttonLeft.onEvent(ButtonEvent.Pressed, function () {
+    turnRatio -= 10
+    updateSteer()
+})
+brick.buttonRight.onEvent(ButtonEvent.Pressed, function () {
+    turnRatio += 10
+    updateSteer()
+})
+
+updateSteer()
+```
+
 ## See also
 
 [tank](/reference/motors/synced/tank), [run](/reference/motors/motor/run)

docs/reference/motors/synced/tank.md

@@ -35,6 +35,12 @@ motors.largeBC.tank(-75, -75)
 
 ## ~
 
+## ~ hint
+
+Only one set of synchronized motors will run at the same time. Once you launch tank/steer, it will cancel any existing synchronized speed command.
+
+## ~
+
 ## Examples
 
 ### Tank forward and backward
@@ -76,6 +82,51 @@ pause(5000)
 motors.stopAll()
 ```
 
+### Tank tester
+
+This program lets you change the tank values using the brick buttons
+
+```typescript
+let tankB = 0;
+let tankC = 0;
+
+brick.showString(`tank tester`, 1)
+brick.showString(`connect motors BC`, 7)
+brick.showString(`up/down for tank B`, 8)
+brick.showString(`left/right for tank C`, 9)
+
+forever(function () {
+    brick.showString(`motor B speed ${motors.largeB.speed()}%`, 4)
+    brick.showString(`motor C speed ${motors.largeC.speed()}%`, 5)
+    pause(100)
+})
+
+function updateTank() {
+    brick.showString(`tank A: ${tankB}%`, 2)
+    brick.showString(`tank B: ${tankC}%`, 3)
+    motors.largeBC.tank(tankB, tankC);
+}
+
+brick.buttonUp.onEvent(ButtonEvent.Pressed, function () {
+    tankB += 10
+    updateTank();
+})
+brick.buttonDown.onEvent(ButtonEvent.Pressed, function () {
+    tankB -= 10
+    updateTank();
+})
+brick.buttonRight.onEvent(ButtonEvent.Pressed, function () {
+    tankC += 10
+    updateTank();
+})
+brick.buttonLeft.onEvent(ButtonEvent.Pressed, function () {
+    tankC -= 10
+    updateTank();
+})
+
+updateTank();
+```
+
 ## See also
 
 [steer](/reference/motors/synced/steer), [run](/reference/motors/motor/run)

jenkins.groovy

@@ -1,41 +0,0 @@
-import jobs.generation.Utilities;
-import jobs.generation.InternalUtilities;
-
-def project = GithubProject
-def projectName = "pxt-ev3"
-
-[true, false].each { isPR ->
-    def newJobName = projectName
-
-    if (isPR) {
-        newJobName += "_PR"
-    } else {
-        newJobName += "_Push"
-    }
-
-    def newJob = job(newJobName) {
-        steps {
-            shell("chmod +x ./jenkins.sh")
-            shell("./jenkins.sh ${isPR}")
-        }
-
-        if (!isPR) {
-            wrappers {
-                credentialsBinding {
-                    string("PXT_ACCESS_TOKEN", "pxt_access_token")
-                    string("PXT_RELEASE_REPO", "pxt_release_repo_ev3")
-                    string("CROWDIN_KEY", "pxt_crowdin_key")
-                }
-            }
-        }
-    }
-
-    Utilities.setMachineAffinity(newJob, "Ubuntu", "20161020")
-    InternalUtilities.standardJobSetup(newJob, project, isPR, "*/*")
-
-    if (isPR) {
-        Utilities.addGithubPRTrigger(newJob, "Default Testing")
-    } else {
-        Utilities.addGithubPushTrigger(newJob)
-    }
-}

jenkins.sh

@@ -1,56 +0,0 @@
-#!/usr/bin/env bash
-
-# Set up NVM
-export NVM_DIR="/home/dotnet-bot/.nvm"
-[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh" 
-
-nvm install 8
-
-# Set up build environment variables
-echo ---------- Setting build environment variables
-echo Git branch: $GIT_BRANCH
-echo isPR: $1
-
-originRegex="^origin/.*"
-branchRegex="^origin/\K.*(?=$)"
-releaseBranchRegex="^(master|v\d+)$"
-
-if [[ "$GIT_BRANCH" =~ $originRegex ]]; then
-    branchName=$(echo ${GIT_BRANCH} | grep -oP $branchRegex)
-    echo Setting TRAVIS_BRANCH to ${branchName}
-    export TRAVIS_BRANCH=${branchName}
-else
-    echo Setting TRAVIS_BRANCH to $GIT_BRANCH
-    export TRAVIS_BRANCH=$GIT_BRANCH
-fi
-
-if [ "$1" == "false" ]; then
-    echo Setting TRAVIS_PULL_REQUEST to false
-    export TRAVIS_PULL_REQUEST=false
-
-    if [[ "$TRAVIS_BRANCH" =~ $releaseBranchRegex ]]; then
-        if [[ -z $PXT_RELEASE_REPO ]]; then
-            echo Cannot find release repo\; skipping tag checks
-        else
-            gitTag=$(git describe --tags --exact-match 2> /dev/null)
-            builtTag=$(git ls-remote --tags $PXT_RELEASE_REPO | grep -o "refs/tags/$gitTag$")
-
-            echo Current tag: $gitTag
-            echo Built tag: $builtTag
-
-            if [[ ! -z $gitTag && -z $builtTag ]]; then
-                echo Built tag not found\; building tag
-                echo Setting TRAVIS_BRANCH to $gitTag
-                export TRAVIS_BRANCH=$gitTag
-                echo Setting TRAVIS_TAG to $gitTag
-                export TRAVIS_TAG=$gitTag
-            else
-                echo Not a tag build
-            fi
-        fi
-    fi
-fi
-
-# Perform build
-npm install
-npm test

libs/color-sensor/color.ts

@@ -1,5 +1,5 @@
 const enum ColorSensorMode {
-    None = -1,
+    None = 0,
     //% block="reflected light intensity"
     ReflectedLightIntensity = 0,
     //% block="ambient light intensity"
@@ -15,7 +15,9 @@ enum LightIntensityMode {
     //% block="reflected light"
     Reflected = ColorSensorMode.ReflectedLightIntensity,
     //% block="ambient light"
-    Ambient = ColorSensorMode.AmbientLightIntensity
+    Ambient = ColorSensorMode.AmbientLightIntensity,
+    //% block="reflected light (raw)"
+    ReflectedRaw = ColorSensorMode.RefRaw
 }
 
 const enum ColorSensorColor {
@@ -93,6 +95,8 @@ namespace sensors {
                 || this.mode == ColorSensorMode.AmbientLightIntensity
                 || this.mode == ColorSensorMode.ReflectedLightIntensity)
                 return this.getNumber(NumberFormat.UInt8LE, 0)
+            if (this.mode == ColorSensorMode.RefRaw || this.mode == ColorSensorMode.RgbRaw)
+                return this.getNumber(NumberFormat.UInt16LE, 0)
             return 0
         }
 
@@ -114,7 +118,7 @@ namespace sensors {
 
         _update(prev: number, curr: number) {
             if (this.calibrating) return; // simply ignore data updates while calibrating
-            if (this.mode == ColorSensorMode.Color)
+            if (this.mode == ColorSensorMode.Color || this.mode == ColorSensorMode.RgbRaw || this.mode == ColorSensorMode.RefRaw)
                 control.raiseEvent(this._id, this._colorEventValue(curr));
             else
                 this.thresholdDetector.setLevel(curr);
@@ -179,6 +183,23 @@ namespace sensors {
             return this.getNumber(NumberFormat.UInt8LE, 0)
         }
 
+        /**
+         * Get the current raw rgb values as an array from the color sensor.
+         * @param sensor the color sensor to query the request
+         */
+        //% help=sensors/color-sensor/rgbraw
+        //% blockId=colorRgbRaw block="**color sensor** %this| RGB raw"
+        //% parts="colorsensor"
+        //% blockNamespace=sensors
+        //% this.fieldEditor="ports"
+        //% weight=1
+        //% group="Color Sensor"
+        //% blockGap=8
+        rgbRaw(): number[] {
+            this.setMode(ColorSensorMode.RgbRaw);
+            return [this.getNumber(NumberFormat.UInt16LE, 0), this.getNumber(NumberFormat.UInt16LE, 2), this.getNumber(NumberFormat.UInt16LE, 4)];
+        }
+
         /**
          * Registers code to run when the ambient light changes.
          * @param condition the light condition
@@ -225,11 +246,16 @@ namespace sensors {
         //% parts="colorsensor"
         //% blockNamespace=sensors
         //% this.fieldEditor="ports"
-        //% weight=87
+        //% weight=87 blockGap=8
         //% group="Color Sensor"
         light(mode: LightIntensityMode) {
             this.setMode(<ColorSensorMode><number>mode)
-            return this.getNumber(NumberFormat.UInt8LE, 0)
+            switch(mode) {
+                case LightIntensityMode.ReflectedRaw:
+                    return this.reflectedLightRaw();
+                default:
+                    return this.getNumber(NumberFormat.UInt8LE, 0)
+            }
         }
 
         /**
@@ -248,6 +274,15 @@ namespace sensors {
             return this.light(LightIntensityMode.Reflected);
         }
 
+        /**
+         * Gets the raw reflection light value
+         */
+        //%
+        reflectedLightRaw(): number {
+            this.setMode(ColorSensorMode.RefRaw);
+            return this.getNumber(NumberFormat.UInt16LE, 0);
+        }
+
         /**
          * Set a threshold value
          * @param condition the dark or bright light condition

libs/core/buttons.ts

@@ -159,12 +159,6 @@ namespace brick {
             if (sl[i])
                 ret |= 1 << i
         }
-        // this needs to be done in query(), which is run without the main JS execution mutex
-        // otherwise, while(true){} will lock the device
-        if (ret & DAL.BUTTON_ID_ESCAPE) {
-            motors.stopAll(); // ensuring that all motors are off
-            control.reset()
-        }
         return ret
     }
 

libs/core/input.ts

@@ -25,8 +25,17 @@ namespace sensors.internal {
         })
     }
 
+    export function bufferToString(buf: Buffer): string {
+        let s = ''
+        for (let i = 0; i < buf.length; i++)
+            s += String.fromCharCode(buf[i])
+
+        return s
+    }
+
     let analogMM: MMap
     let uartMM: MMap
+    let IICMM: MMap
     let devcon: Buffer
     let sensorInfos: SensorInfo[]
 
@@ -36,11 +45,13 @@ namespace sensors.internal {
         sensors: Sensor[]
         connType: number
         devType: number
+        iicid: string
 
         constructor(p: number) {
             this.port = p
             this.connType = DAL.CONN_NONE
             this.devType = DAL.DEVICE_TYPE_NONE
+            this.iicid = ''
             this.sensors = []
         }
     }
@@ -57,20 +68,21 @@ namespace sensors.internal {
         uartMM = control.mmap("/dev/lms_uart", UartOff.Size, 0)
         if (!uartMM) control.fail("no uart sensor")
 
-        forever(() => {
-            detectDevices()
-            pause(500)
-        })
+        IICMM = control.mmap("/dev/lms_iic", IICOff.Size, 0)
+        if (!IICMM) control.fail("no iic sensor")
 
-        for (let info_ of sensorInfos) {
-            let info = info_
+        unsafePollForChanges(500, 
+            () => { return hashDevices(); }, 
+            (prev, curr) => { detectDevices(); 
+        });
+        sensorInfos.forEach(info => {
             unsafePollForChanges(50, () => {
                 if (info.sensor) return info.sensor._query()
                 return 0
             }, (prev, curr) => {
                 if (info.sensor) info.sensor._update(prev, curr)
             })
-        }
+        })
 
     }
 
@@ -89,6 +101,15 @@ namespace sensors.internal {
         //serial.writeLine("UART " + port + " / " + mode + " - " + info)
     }
 
+    export function readIICID(port: number) {
+        const buf = output.createBuffer(IICStr.Size)
+        buf[IICStr.Port] = port
+        IICMM.ioctl(IO.IIC_READ_TYPE_INFO, buf)
+        const manufacturer = bufferToString(buf.slice(IICStr.Manufacturer, 8))
+        const sensorType = bufferToString(buf.slice(IICStr.SensorType, 8))
+        return manufacturer + sensorType;
+    }
+
     export function getBatteryInfo(): { temp: number; current: number } {
         init();
         return {
@@ -97,52 +118,87 @@ namespace sensors.internal {
         }
     }
 
-    function detectDevices() {
-        let conns = analogMM.slice(AnalogOff.InConn, DAL.NUM_INPUTS)
-        let numChanged = 0
+    function hashDevices(): number {
+        const conns = analogMM.slice(AnalogOff.InConn, DAL.NUM_INPUTS)
+        let r = 0;
+        for(let i = 0; i < conns.length; ++i) {
+            r = (r << 8 | conns[i]);
+        }
+        return r;
+    }
 
-        for (let info of sensorInfos) {
-            let newConn = conns[info.port]
-            if (newConn == info.connType)
-                continue
+    let nonActivated = 0;
+    function detectDevices() {
+        //control.dmesg(`detect devices (${nonActivated} na)`)
+        const conns = analogMM.slice(AnalogOff.InConn, DAL.NUM_INPUTS)
+        let numChanged = 0;
+        const uartSensors: SensorInfo[] = [];
+
+        for (const sensorInfo of sensorInfos) {
+            const newConn = conns[sensorInfo.port]
+            if (newConn == sensorInfo.connType) {
+                // control.dmesg(`connection unchanged ${newConn} at ${sensorInfo.port}`)
+                continue;
+            }
             numChanged++
-            info.connType = newConn
-            info.devType = DAL.DEVICE_TYPE_NONE
+            sensorInfo.connType = newConn
+            sensorInfo.devType = DAL.DEVICE_TYPE_NONE
             if (newConn == DAL.CONN_INPUT_UART) {
-                control.dmesg(`new UART connection at ${info.port}`)
-                setUartMode(info.port, 0)
-                let uinfo = readUartInfo(info.port, 0)
-                info.devType = uinfo[TypesOff.Type]
-                control.dmesg(`UART type ${info.devType}`)
+                control.dmesg(`new UART connection at ${sensorInfo.port}`)
+                updateUartMode(sensorInfo.port, 0);
+                uartSensors.push(sensorInfo);
+            } else if (newConn == DAL.CONN_NXT_IIC) {
+                control.dmesg(`new IIC connection at ${sensorInfo.port}`)
+                sensorInfo.devType = DAL.DEVICE_TYPE_IIC_UNKNOWN
+                sensorInfo.iicid = readIICID(sensorInfo.port)
+                control.dmesg(`IIC ID ${sensorInfo.iicid.length}`)
             } else if (newConn == DAL.CONN_INPUT_DUMB) {
-                control.dmesg(`new DUMB connection at ${info.port}`)
+                control.dmesg(`new DUMB connection at ${sensorInfo.port}`)
                 // TODO? for now assume touch
-                info.devType = DAL.DEVICE_TYPE_TOUCH
+                sensorInfo.devType = DAL.DEVICE_TYPE_TOUCH
             } else if (newConn == DAL.CONN_NONE || newConn == 0) {
-                control.dmesg(`disconnect at ${info.port}`)
+                control.dmesg(`disconnect at port ${sensorInfo.port}`)
             } else {
-                control.dmesg(`unknown connection type: ${newConn} at ${info.port}`)
+                control.dmesg(`unknown connection type: ${newConn} at ${sensorInfo.port}`)
             }
         }
 
-        if (numChanged == 0)
+        if (uartSensors.length > 0) {
+            setUartModes();
+            for (const sensorInfo of uartSensors) {
+                let uinfo = readUartInfo(sensorInfo.port, 0)
+                sensorInfo.devType = uinfo[TypesOff.Type]
+                control.dmesg(`UART type ${sensorInfo.devType}`)
+            }
+        }
+
+        if (numChanged == 0 && nonActivated == 0)
             return
 
-        for (let si of sensorInfos) {
-            if (si.sensor && si.sensor._deviceType() != si.devType) {
-                si.sensor = null
-            }
-            if (si.devType != DAL.DEVICE_TYPE_NONE) {
-                // TODO figure out compiler problem when '|| null' is added here!
-                si.sensor = si.sensors.filter(s => s._deviceType() == si.devType)[0]
-                if (si.sensor == null) {
-                    control.dmesg(`sensor not found for type=${si.devType} at ${si.port}`)
+        control.dmesg(`updating sensor status`)
+        nonActivated = 0;
+        for (const sensorInfo of sensorInfos) {
+            if (sensorInfo.devType == DAL.DEVICE_TYPE_IIC_UNKNOWN) {
+                sensorInfo.sensor = sensorInfo.sensors.filter(s => s._IICId() == sensorInfo.iicid)[0]
+                if (!sensorInfo.sensor) {
+                    control.dmesg(`sensor not found for iicid=${sensorInfo.iicid} at ${sensorInfo.port}`)
+                    nonActivated++;
                 } else {
-                    control.dmesg(`sensor connected type=${si.devType} at ${si.port}`)
-                    si.sensor._activated()
+                    control.dmesg(`sensor connected iicid=${sensorInfo.iicid} at ${sensorInfo.port}`)
+                    sensorInfo.sensor._activated()
+                }
+            } else if (sensorInfo.devType != DAL.DEVICE_TYPE_NONE) {
+                sensorInfo.sensor = sensorInfo.sensors.filter(s => s._deviceType() == sensorInfo.devType)[0]
+                if (!sensorInfo.sensor) {
+                    control.dmesg(`sensor not found for type=${sensorInfo.devType} at ${sensorInfo.port}`)
+                    nonActivated++;
+                } else {
+                    control.dmesg(`sensor connected type=${sensorInfo.devType} at ${sensorInfo.port}`)
+                    sensorInfo.sensor._activated()
                 }
             }
         }
+        //control.dmesg(`detect devices done`)
     }
 
     export class Sensor extends control.Component {
@@ -187,6 +243,10 @@ namespace sensors.internal {
         _deviceType() {
             return 0
         }
+
+        _IICId() {
+            return ''
+        }
     }
 
     export class AnalogSensor extends Sensor {
@@ -207,12 +267,11 @@ namespace sensors.internal {
         constructor(port: number) {
             super(port)
             this.mode = 0
-            this.realmode = -1
+            this.realmode = 0
         }
 
         _activated() {
             this.realmode = 0
-            // uartReset(this.port) // TODO is it ever needed?
             this._setMode(this.mode)
         }
 
@@ -243,6 +302,55 @@ namespace sensors.internal {
         }
     }
 
+    export class IICSensor extends Sensor {
+        protected mode: number // the mode user asked for
+        protected realmode: number // the mode the hardware is in
+        private readLength: number
+
+        constructor(port: number) {
+            super(port)
+            this.mode = 0
+            this.realmode = 0
+            this.readLength = 1;
+        }
+
+        _activated() {
+            this.realmode = 0
+            this._setMode(this.mode)
+        }
+
+        protected _setMode(m: number) {
+            let v = m | 0
+            this.mode = v
+            if (!this.isActive()) return
+            if (this.realmode != this.mode) {
+                this.realmode = v
+                setIICMode(this._port, this._deviceType(), v)
+            }
+        }
+
+        getBytes(): Buffer {
+            return getIICBytes(this.isActive() ? this._port : -1, this.readLength)
+        }
+
+        getNumber(fmt: NumberFormat, off: number) {
+            if (!this.isActive())
+                return 0
+            return getIICNumber(this.readLength, fmt, off, this._port)
+        }
+
+        transaction(deviceAddress: number, write: number[], read: number) {
+            this.readLength = read;
+            transactionIIC(this._port, deviceAddress, write, read)
+        }
+
+        _deviceType() {
+            return DAL.DEVICE_TYPE_IIC_UNKNOWN
+        }
+    }
+
+    export const iicsensor = new IICSensor(3)
+
     function uartReset(port: number) {
         if (port < 0) return
         control.dmesg(`UART reset at ${port}`)
@@ -267,6 +375,7 @@ namespace sensors.internal {
     }
 
     function uartClearChange(port: number) {
+        control.dmesg(`UART clear change`);
         const UART_DATA_READY = 8
         const UART_PORT_CHANGED = 1
         while (true) {
@@ -288,20 +397,43 @@ namespace sensors.internal {
         }
     }
 
+    function setUartModes() {
+        control.dmesg(`UART set modes`)
+        uartMM.ioctl(IO.UART_SET_CONN, devcon)
+        const ports: number[] = [];
+        for (let port = 0; port < DAL.NUM_INPUTS; ++port) {
+            if (devcon.getNumber(NumberFormat.Int8LE, DevConOff.Connection + port) == DAL.CONN_INPUT_UART) {
+                ports.push(port);
+            }
+        }
+
+        while (ports.length) {
+            const port = ports.pop();
+            const status = waitNonZeroUartStatus(port)
+            control.dmesg(`UART set mode ${status} at ${port}`);
+        }
+    }
+
+    function updateUartMode(port: number, mode: number) {
+        control.dmesg(`UART set mode to ${mode} at ${port}`)
+        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Connection + port, DAL.CONN_INPUT_UART)
+        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Type + port, 33)
+        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Mode + port, mode)
+    }
+
     function setUartMode(port: number, mode: number) {
         const UART_PORT_CHANGED = 1
         while (true) {
             if (port < 0) return
-            control.dmesg(`UART set mode to ${mode} at ${port}`)
-            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Connection + port, DAL.CONN_INPUT_UART)
-            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Type + port, 33)
-            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Mode + port, mode)
+            updateUartMode(port, mode);
             uartMM.ioctl(IO.UART_SET_CONN, devcon)
             let status = waitNonZeroUartStatus(port)
             if (status & UART_PORT_CHANGED) {
+                control.dmesg(`UART clear changed at ${port}`)
                 uartClearChange(port)
             } else {
-                break
+                control.dmesg(`UART status ${status}`);
+                break;
             }
             pause(10)
         }
@@ -322,6 +454,48 @@ namespace sensors.internal {
             UartOff.Raw + DAL.MAX_DEVICE_DATALENGTH * 300 * port + DAL.MAX_DEVICE_DATALENGTH * index + off)
     }
 
+    export function setIICMode(port: number, type: number, mode: number) {
+        if (port < 0) return;
+        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Connection + port, DAL.CONN_NXT_IIC)
+        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Type + port, type)
+        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Mode + port, mode)
+        IICMM.ioctl(IO.IIC_SET_CONN, devcon)
+    }
+
+    export function transactionIIC(port: number, deviceAddress: number, writeBuf: number[], readLen: number) {
+        if (port < 0) return;
+        let iicdata = output.createBuffer(IICDat.Size)
+        iicdata.setNumber(NumberFormat.Int8LE, IICDat.Port, port)
+        iicdata.setNumber(NumberFormat.Int8LE, IICDat.Repeat, 0)
+        iicdata.setNumber(NumberFormat.Int16LE, IICDat.Time, 0)
+        iicdata.setNumber(NumberFormat.Int8LE, IICDat.WrLng, writeBuf.length + 1)
+        for (let i = 0; i < writeBuf.length; i++)
+            iicdata.setNumber(NumberFormat.Int8LE, IICDat.WrData + i + 1, writeBuf[i])
+        iicdata.setNumber(NumberFormat.Int8LE, IICDat.WrData, deviceAddress)
+        iicdata.setNumber(NumberFormat.Int8LE, IICDat.RdLng, readLen)
+        IICMM.ioctl(IO.IIC_SETUP, iicdata)
+    }
+
+    export function getIICBytes(port: number, length: number) {
+        if (port < 0) return output.createBuffer(length);
+        let index = IICMM.getNumber(NumberFormat.UInt16LE, IICOff.Actual + port * 2);
+        let buf = IICMM.slice(
+            IICOff.Raw + DAL.MAX_DEVICE_DATALENGTH * 300 * port + DAL.MAX_DEVICE_DATALENGTH * index,
+            length
+        );
+
+        // Reverse
+        for (let i = 0; i < length / 2; i++) {
+            let c = buf[i]
+            buf[i] = buf[length - i - 1]
+            buf[length - i - 1] = c
+        }
+        return buf;
+    }
+
+    export function getIICNumber(length: number, format: NumberFormat, off: number, port: number) {
+        return getIICBytes(port, length).getNumber(format, off)
+    }
 
     const enum NxtColOff {
         Calibration = 0, // uint32[4][3]
@@ -405,6 +579,52 @@ namespace sensors.internal {
         Size = 58
     }
 
+    const enum IICOff {
+        TypeData = 0, // Types[8][4]
+        Repeat = 1792, // uint16[300][4]
+        Raw = 4192, // int8[32][300][4]
+        Actual = 42592, // uint16[4]
+        LogIn = 42600, // uint16[4]
+        Status = 42608, // int8[4]
+        Output = 42612, // int8[32][4]
+        OutputLength = 42740, // int8[4]
+        Size = 42744
+    }
+
+    const enum IICCtlOff {
+        TypeData = 0, // Types
+        Port = 56, // int8
+        Mode = 57, // int8
+        Size = 58
+    }
+
+    const enum IICDat {
+        Result = 0,  // result
+        Port = 4, // int8
+        Repeat = 5, // int8
+        Time = 6, // int16
+        WrLng = 8, // int8
+        WrData = 9, // int8[32]
+        RdLng = 41, // int8
+        RdData = 42, //int8[32]
+        Size = 74,
+    }
+
+    const enum IICStr {
+        Port = 0, // int8
+        Time = 2, // int16
+        Type = 4, // int8
+        Mode = 5, // int8
+        Manufacturer = 6, // int8[9]
+        SensorType = 15, // int[9]
+        SetupLng = 24, // int8
+        SetupString = 28, // ulong
+        PollLng = 32, // int8
+        PollString = 36, // ulong
+        ReadLng = 40, // int8
+        Size = 44
+    }
+
     const enum IO {
         UART_SET_CONN = 0xc00c7500,
         UART_READ_MODE_INFO = 0xc03c7501,
@@ -472,7 +692,7 @@ namespace sensors {
         }
 
         public threshold(t: ThresholdState): number {
-            switch(t) {
+            switch (t) {
                 case ThresholdState.High: return this.highThreshold;
                 case ThresholdState.Low: return this.lowThreshold;
                 default: return (this.max - this.min) / 2;
@@ -512,5 +732,5 @@ namespace sensors {
                     break;
             }
         }
-    }    
-}
+    }
+}

libs/core/linux.cpp

@@ -14,6 +14,9 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <malloc.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include "ev3const.h"
 
 #define THREAD_DBG(...)
 
@@ -144,6 +147,29 @@ static void startUsb() {
     pthread_detach(pid);
 }
 
+static void *exitThread(void *) {
+    int fd = open("/dev/lms_ui", O_RDWR, 0666);
+    if (fd < 0)
+        return 0;
+    uint8_t *data =
+        (uint8_t *)mmap(NULL, NUM_BUTTONS, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+    if (data == MAP_FAILED) {
+        close(fd);
+        return 0;
+    }
+    for (;;) {
+        if (data[5])
+            target_reset();
+        sleep_core_us(50000);
+    }
+}
+
+static void startExitThread() {
+    pthread_t pid;
+    pthread_create(&pid, NULL, exitThread, NULL);
+    pthread_detach(pid);
+}
+
 void sendUsb(uint16_t code, const char *data, int len) {
     while (len > 0) {
         int sz = len;
@@ -489,14 +515,22 @@ void runLMS() {
 }
 
 void stopMotors() {
-    uint8_t cmd[2] = { 0xA3, 0x0F };
+    uint8_t cmd[3] = {opOutputStop, 0x0F, 0};
     int fd = open("/dev/lms_pwm", O_RDWR);
-    write(fd, cmd, 2);
+    write(fd, cmd, 3);
+    close(fd);
+}
+
+void stopProgram() {
+    uint8_t cmd[1] = {opOutputProgramStop};
+    int fd = open("/dev/lms_pwm", O_RDWR);
+    write(fd, cmd, 1);
     close(fd);
 }
 
 extern "C" void target_reset() {
     stopMotors();
+    stopProgram();
     if (lmsPid)
         runLMS();
     else
@@ -510,6 +544,7 @@ void initRuntime() {
     DMESG("runtime starting...");
     stopLMS();
     startUsb();
+    startExitThread();
     pthread_t disp;
     pthread_create(&disp, NULL, evtDispatcher, NULL);
     pthread_detach(disp);

libs/core/output.ts

@@ -134,6 +134,7 @@ namespace motors {
         protected _brake: boolean;
         private _pauseOnRun: boolean;
         private _initialized: boolean;
+        private _brakeSettleTime: number;
         private _init: () => void;
         private _run: (speed: number) => void;
         private _move: (steps: boolean, stepsOrTime: number, speed: number) => void;
@@ -147,6 +148,7 @@ namespace motors {
             this._brake = false;
             this._pauseOnRun = true;
             this._initialized = false;
+            this._brakeSettleTime = 10;
             this._init = init;
             this._run = run;
             this._move = move;
@@ -204,6 +206,20 @@ namespace motors {
             writePWM(b)
         }
 
+        /** 
+         * Set the settle time after braking in milliseconds (default is 10ms).
+        */
+        //% blockId=motorSetBrakeSettleTime block="set %motor|brake settle time %millis|ms"
+        //% motor.fieldEditor="motors"
+        //% weight=1 blockGap=8
+        //% group="Properties"
+        //% millis.defl=200 millis.min=0 millis.max=500
+        setBrakeSettleTime(millis: number) {
+            this.init();
+            // ensure in [0,500]
+            this._brakeSettleTime = Math.max(0, Math.min(500, millis | 0))
+        }
+
         /**
          * Stops the motor(s).
          */
@@ -221,8 +237,8 @@ namespace motors {
         protected settle() {
             // if we've recently completed a motor command with brake
             // allow 500ms for robot to settle
-            if (this._brake)
-                pause(500);
+            if (this._brake && this._brakeSettleTime > 0)
+                pause(this._brakeSettleTime);
         }
 
         protected pauseOnRun(stepsOrTime: number) {
@@ -323,7 +339,7 @@ namespace motors {
         }
 
         protected setOutputType(large: boolean) {
-           for (let i = 0; i < DAL.NUM_OUTPUTS; ++i) {
+            for (let i = 0; i < DAL.NUM_OUTPUTS; ++i) {
                 if (this._port & (1 << i)) {
                     // (0x07: Large motor, Medium motor = 0x08)
                     MotorBase.output_types[i] = large ? 0x07 : 0x08;
@@ -396,7 +412,7 @@ namespace motors {
          */
         //% blockId=outputMotorSetRegulated block="set %motor|regulated %value=toggleOnOff"
         //% motor.fieldEditor="motors"
-        //% weight=58
+        //% weight=58 blockGap=8
         //% group="Properties"
         //% help=motors/motor/set-regulated
         setRegulated(value: boolean) {
@@ -545,10 +561,12 @@ namespace motors {
             speedRight = Math.clamp(-100, 100, speedRight >> 0);
 
             const speed = Math.abs(speedLeft) > Math.abs(speedRight) ? speedLeft : speedRight;
-            const turnRatio = speedLeft == speed
-                ? (100 - speedRight / speedLeft * 100)
-                : (speedLeft / speedRight * 100 - 100);
+            let turnRatio = speedLeft == speed
+                ? speedLeft == 0 ? 0 : (100 - speedRight / speedLeft * 100)
+                : speedRight == 0 ? 0 : (speedLeft / speedRight * 100 - 100);
+            turnRatio = Math.floor(turnRatio);
 
+            //control.dmesg(`tank ${speedLeft} ${speedRight} => ${turnRatio} ${speed}`)
             this.steer(turnRatio, speed, value, unit);
         }
 

libs/gyro-sensor/docs/reference/sensors/gyro.md

@@ -3,6 +3,7 @@
 ```cards
 sensors.gyro1.angle();
 sensors.gyro1.rate();
+sensors.gyro1.calibrate();
 sensors.gyro1.reset();
 ```
 
@@ -10,4 +11,6 @@ sensors.gyro1.reset();
 
 [angle](/reference/sensors/gyro/angle),
 [rate](/reference/sensors/gyro/rate),
+[reset](/reference/sensors/gyro/calibrate),
 [reset](/reference/sensors/gyro/reset)
+

libs/gyro-sensor/docs/reference/sensors/gyro/angle.md

@@ -12,7 +12,7 @@ When the brick changes its position, it's moved in the direction of one of the a
 
 ## Accuracy and calibration
 
-Gyro sensors aren't perfectly accurate. Sometimes, because of temperature and changes in the way elecricity behaves in the sensor, the gyro returns a small error in it's measurement. This causes the gyro sensor to return an incorrect value for the amount of angle it detected. This might make your robot drive off course and not go to where you want it to.
+Gyro sensors aren't perfectly accurate. Sometimes, because of temperature and changes in the way electricity behaves in the sensor, the gyro returns a small error in it's measurement. This causes the gyro sensor to return an incorrect value for the amount of angle it detected. This might make your robot drive off course and not go to where you want it to.
 
 ### Drift
 
@@ -20,7 +20,7 @@ If you want to turn the tank or robot you built to the left by 45 degrees, you m
 
 The problem is that when you need to read the angle measurement frequently, the amount of error in the angle measurement may continue to increase. If the sensor thought it moved by 45 degrees the first time instead of really 49 degrees, your second turn will put you at 98 degrees when the sensor said 90 degrees. If you want a robot to turn right 90 degrees and drive for 5 meters, it might actually turn 98 degrees and drive 0.7 meters off course before it stops. This error in the sensor's measurement is called _drift_.
 
-### Time to reset
+### Calibration
 
 If errors in the angle values returned by the gyro sensor are making your project not work right, then it's time to **[reset](/reference/sensors/gyro/reset)**. A reset will return the gyro sensor's current angle value back to `0` and _calibrate_ for drift. Calibration is the process of finding out how much error there is in a sensor's measurement and then removing the error from the value returned to your program.
 
@@ -42,7 +42,14 @@ Turn the brick and press ENTER to see the current rotation angle of `gyro 2`.
 
 ```blocks
 brick.buttonEnter.onEvent(ButtonEvent.Pressed, function () {
-    brick.showNumber(sensors.gyro2.angle(), 1)
+    sensors.gyro2.reset()
+})
+brick.buttonLeft.onEvent(ButtonEvent.Pressed, function () {
+    sensors.gyro2.calibrate()
+})
+forever(function () {
+    brick.showNumber(control.millis(), 1)
+    brick.showNumber(sensors.gyro2.angle(), 2)
 })
 ```
 

libs/gyro-sensor/docs/reference/sensors/gyro/calibrate.md

@@ -0,0 +1,51 @@
+# calibrate
+
+Reset the zero reference for the gyro to current position of the brick.
+
+```sig
+sensors.gyro2.calibrate()
+```
+
+To make the gyro measure rotation angle from the current position of the brick, it is recalibrated. That is, the brick's current position is set to `0` degrees and rotation angle measurements start from there.
+
+This function adds a few pauses to ensure that the robot is still. If you only want to reset the sensor, use  [reset](/reference/gyro-sensor/reset).
+
+
+## ~hint
+
+The current position is considered to be the [_horizon_](https://en.wikipedia.org/wiki/Attitude_indicator) or a place that is the _plane of reference_ (this is possibly someplace that's flat for a horizontal reference).
+
+## ~
+
+## ~hint
+
+**Important**
+
+To properly reset the gyro, the brick must remain still (undisturbed) while the reset operation takes place.
+
+## ~
+
+## Calibration states
+
+Calibration happens in the following phases and each phase is tracked by the brick status light.
+
+* **orange**: sensor initialization. This phase ensures that the sensor is in the desired mode and ready to collect data.
+* **orange pulse**: data collection. Light information is being collected, move the sensor over the various light sources to detect.
+* **green**: calibration success. The calibration data has been saved.
+* **red flash**: sensor failure. We were unable to connect to the sensor.
+
+## Example
+Set the brick on a flat surface. Reset `gyro 2` and tilt the brick slightly. Reset it again while it's still tilted. Lay the brick down flat again and display the angle measurement.
+
+```blocks
+brick.buttonLeft.onEvent(ButtonEvent.Pressed, function () {
+    sensors.gyro2.calibrate()
+})
+forever(function() {
+    brick.showNumber(sensors.gyro2.angle(), 1)
+})
+```
+
+## See also
+
+[angle](/reference/sensors/gyro/angle), [rate](/reference/sensors/gyro/rate)

libs/gyro-sensor/docs/reference/sensors/gyro/rate.md

@@ -13,12 +13,39 @@ When the brick is in motion, it moves in the direction of one of axes used to me
 
 * a [number](/types/number) that is the current rate of rotation in degrees per second.
 
+## ~hint
+
+## Accuracy and calibration
+
+Gyro sensors aren't perfectly accurate. Sometimes, because of temperature and changes in the way electricity behaves in the sensor, the gyro returns a small error in it's measurement. This causes the gyro sensor to return an incorrect value for the amount of angle it detected. This might make your robot drive off course and not go to where you want it to.
+
+### Drift
+
+If you want to turn the tank or robot you built to the left by 45 degrees, you might run the motor on the right side until the gyro reported that you turned by 45 degrees. What if the gyro was getting an error of 4 degrees every time it measured an angle? You may have actually turned 49 degrees when you expected to turn 45 degrees. Well, that might not be too bad if you use the gyro's angle value only once. It's fine if you just wanted to turn and stop or drive a short distance in only that direction.
+
+The problem is that when you need to read the angle measurement frequently, the amount of error in the angle measurement may continue to increase. If the sensor thought it moved by 45 degrees the first time instead of really 49 degrees, your second turn will put you at 98 degrees when the sensor said 90 degrees. If you want a robot to turn right 90 degrees and drive for 5 meters, it might actually turn 98 degrees and drive 0.7 meters off course before it stops. This error in the sensor's measurement is called _drift_.
+
+### Calibration
+
+If errors in the angle values returned by the gyro sensor are making your project not work right, then it's time to **[reset](/reference/sensors/gyro/reset)**. A reset will return the gyro sensor's current angle value back to `0` and _calibrate_ for drift. Calibration is the process of finding out how much error there is in a sensor's measurement and then removing the error from the value returned to your program.
+
+Are you using a gyro sensor in your project and need accuracy for your angle values? You should reset the gyro sensor at a regular intervals to improve precision in the values reported to your program.
+
+## ~
+
 ## Example
 
 Flash the status light to red if the roll rate of `gyro 2` is more that `30` degrees per second.
 
 ```blocks
+brick.buttonEnter.onEvent(ButtonEvent.Pressed, function () {
+    sensors.gyro2.reset()
+})
+brick.buttonLeft.onEvent(ButtonEvent.Pressed, function () {
+    sensors.gyro2.calibrate()
+})
 forever(function () {
+    brick.showNumber(sensors.gyro2.rate(), 2)
     if (sensors.gyro2.rate() > 30) {
         brick.setStatusLight(StatusLight.RedFlash)
     } else {

libs/gyro-sensor/docs/reference/sensors/gyro/reset.md

@@ -1,6 +1,6 @@
 # reset
 
-Reset the zero reference for the gyro to current position of the brick.
+Reset the gyro sensor.
 
 ```sig
 sensors.gyro2.reset()
@@ -8,6 +8,8 @@ sensors.gyro2.reset()
 
 To make the gyro measure rotation angle from the current position of the brick, it is recalibrated. That is, the brick's current position is set to `0` degrees and rotation angle measurements start from there.
 
+This function only resets the sensor; if you wish to have progress indication and a more robust calibration sequence, use [calibrate](/reference/gyro-sensor/calibrate).
+
 ## ~hint
 
 The current position is considered to be the [_horizon_](https://en.wikipedia.org/wiki/Attitude_indicator) or a place that is the _plane of reference_ (this is possibly someplace that's flat for a horizontal reference).
@@ -18,27 +20,18 @@ The current position is considered to be the [_horizon_](https://en.wikipedia.or
 
 **Important**
 
-To properly reset the gyro, the brick must remain still (undistrurbed) while the reset operation takes place.
+To properly reset the gyro, the brick must remain still (undisturbed) while the reset operation takes place.
 
 ## ~
 
-## Calibration states
-
-Calibration happens in the following phases and each phase is tracked by the brick status light.
-
-* **orange**: sensor initialization. This phase ensures that the sensor is in the desired mode and ready to collect data.
-* **orange pulse**: data collection. Light information is being collected, move the sensor over the various light sources to detect.
-* **green**: calibration success. The calibration data has been saved.
-* **red flash**: sensor failure. We were unable to connect to the sensor.
-
 ## Example
-Set the brick on a flat surface. Reset `gyro 2` and tilt the brick slighly. Reset it again while it's still tilted. Lay the brick down flat again and display the angle measurement.
+Set the brick on a flat surface. Reset `gyro 2` and tilt the brick slightly. Reset it again while it's still tilted. Lay the brick down flat again and display the angle measurement.
 
 ```blocks
 brick.buttonLeft.onEvent(ButtonEvent.Pressed, function () {
     sensors.gyro2.reset()
 })
-brick.buttonRight.onEvent(ButtonEvent.Pressed, function () {
+forever(function() {
     brick.showNumber(sensors.gyro2.angle(), 1)
 })
 ```

libs/gyro-sensor/gyro.ts

@@ -1,5 +1,5 @@
 const enum GyroSensorMode {
-    None = -1,
+    None = 0,
     Angle = 0,
     Rate = 1,
 }
@@ -9,12 +9,12 @@ namespace sensors {
     export class GyroSensor extends internal.UartSensor {
         private calibrating: boolean;
         private _drift: number;
-        private _drifting: boolean;
+        private _driftCorrection: boolean;
         constructor(port: number) {
             super(port)
             this.calibrating = false;
             this._drift = 0;
-            this._drifting = true;
+            this._driftCorrection = false;
             this.setMode(GyroSensorMode.Rate);
         }
 
@@ -70,14 +70,78 @@ namespace sensors {
 
             this.setMode(GyroSensorMode.Rate);
             let curr = this._query();
-            if (Math.abs(curr) < 20) {
-                const p = 0.0005;
+            if (Math.abs(curr) < 4 && this._driftCorrection) {
+                const p = 0.01;
                 this._drift = (1 - p) * this._drift + p * curr;
-                curr -= this._drift;
+                curr = Math.round(curr - this._drift);
             }
             return curr;
         }
 
+        /**
+         * Forces a calibration of the with light progress indicators. 
+         * Must be called when the sensor is completely still.
+         */
+        //% help=sensors/gyro/calibrate
+        //% block="calibrate **gyro** %this|"
+        //% blockId=gyroCalibrate
+        //% parts="gyroscope"
+        //% blockNamespace=sensors
+        //% this.fieldEditor="ports"
+        //% weight=51 blockGap=8
+        //% group="Gyro Sensor"
+        calibrate(): void {
+            if (this.calibrating) return; // already in calibration mode
+
+            const statusLight = brick.statusLight(); // save current status light
+            brick.setStatusLight(StatusLight.Orange);
+
+            this.calibrating = true;
+            // may be triggered by a button click,
+            // give time for robot to settle
+            pause(700);
+
+            // calibrating
+            brick.setStatusLight(StatusLight.OrangePulse);
+
+            // send a reset command
+            super.reset();
+            // wait till sensor is live
+            pauseUntil(() => this.isActive(), 7000);
+            // mode toggling
+            this.setMode(GyroSensorMode.Rate);
+            this.setMode(GyroSensorMode.Angle);
+            // switch back to the desired mode
+            this.setMode(this.mode);
+
+            // check sensor is ready
+            if (!this.isActive()) {
+                brick.setStatusLight(StatusLight.RedFlash); // didn't work
+                pause(2000);
+                brick.setStatusLight(statusLight); // restore previous light
+                this.calibrating = false;
+                return;
+            }
+
+            // compute drift
+            this._drift = 0;
+            if (this._driftCorrection && this.mode == GyroSensorMode.Rate) {
+                const n = 100;
+                for (let i = 0; i < n; ++i) {
+                    this._drift += this._query();
+                    pause(4);
+                }
+                this._drift /= n;
+            }
+
+            brick.setStatusLight(StatusLight.Green); // success
+            pause(1000);
+            brick.setStatusLight(statusLight); // resture previous light
+
+            // and we're done
+            this.calibrating = false;
+        }
+
         /**
          * Forces a calibration of the gyro. Must be called when the sensor is completely still.
          */
@@ -92,49 +156,10 @@ namespace sensors {
         reset(): void {
             if (this.calibrating) return; // already in calibration mode
 
-            const statusLight = brick.statusLight(); // save current status light
-            brick.setStatusLight(StatusLight.Orange);
-
             this.calibrating = true;
-            // may be triggered by a button click,
-            // give time for robot to settle
-            pause(700);
             // send a reset command
             super.reset();
-            // switch back to the desired mode
-            this.setMode(this.mode);
-            // wait till sensor is live
-            pauseUntil(() => this.isActive(), 5000);
-
-            // check sensor is ready
-            if (!this.isActive()) {
-                brick.setStatusLight(StatusLight.RedFlash); // didn't work
-                pause(2000);
-                brick.setStatusLight(statusLight); // restore previous light
-                return;
-            }
-
-            // give it a bit of time to init
-            pause(1000)
-
-            // calibrating
-            brick.setStatusLight(StatusLight.OrangePulse);
-
-            // compute drift
-            this._drift = 0;
-            if (this.mode == GyroSensorMode.Rate) {
-                for (let i = 0; i < 200; ++i) {
-                    this._drift += this._query();
-                    pause(4);
-                }
-                this._drift /= 200;
-            }
-
-            brick.setStatusLight(StatusLight.Green); // success
-            pause(1000);
-            brick.setStatusLight(statusLight); // resture previous light
-
-            // and we're done
+            // and done
             this.calibrating = false;
         }
 
@@ -152,7 +177,8 @@ namespace sensors {
          */
         //%
         setDriftCorrection(enabled: boolean) {
-            this._drifting = enabled;
+            this._driftCorrection = enabled;
+            this._drift = 0;
         }
     }
 

libs/infrared-sensor/ir.ts

@@ -1,5 +1,5 @@
 const enum InfraredSensorMode {
-    None = -1,
+    None = 0,
     Proximity = 0,
     Seek = 1,
     RemoteControl = 2,

libs/storage/pxt.json

@@ -1,6 +1,6 @@
 {
     "name": "storage",
-    "description": "USB Pen-drive support and flash storage",
+    "description": "USB Pen-drive support and flash storage - beta",
     "files": [
         "storage.cpp",
         "storage-core.ts",

package.json

@@ -1,8 +1,8 @@
 {
   "name": "pxt-ev3",
-  "version": "1.0.10",
+  "version": "1.1.14",
   "description": "LEGO MINDSTORMS EV3 for Microsoft MakeCode",
-  "private": true,
+  "private": false,
   "keywords": [
     "JavaScript",
     "education",
@@ -39,7 +39,7 @@
     "webfonts-generator": "^0.4.0"
   },
   "dependencies": {
-    "pxt-common-packages": "0.23.56",
+    "pxt-common-packages": "0.23.61",
     "pxt-core": "4.0.9"
   },
   "scripts": {

pxtarget.json

@@ -16,13 +16,15 @@
         "libs/infrared-sensor",
         "libs/gyro-sensor",
         "libs/screen",
-        "libs/ev3"
+        "libs/ev3",
+        "libs/storage"
     ],
     "simulator": {
         "autoRun": true,
         "streams": true,
         "aspectRatio": 0.5,
         "parts": false,
+        "enableTrace": true,
         "boardDefinition": {
             "visual": "ev3"
         }

sim/state/input.ts

@@ -27,6 +27,7 @@ namespace pxsim.sensors {
 
     export function __sensorUsed(port: number, type: number) {
         //console.log("SENSOR INIT " + port + ", type: " + type);
+        if (type == DAL.DEVICE_TYPE_IIC_UNKNOWN) return; // Ignore IIC        
         if (!ev3board().hasSensor(port)) {
             const sensor = ev3board().getSensor(port, type);
             runtime.queueDisplayUpdate();

sim/state/motornode.ts

@@ -63,6 +63,12 @@ namespace pxsim {
             delete this.speedCmd;
             delete this.speedCmdValues;
             delete this._synchedMotor;
+            this.setChangedState();
+        }        
+
+        clearSyncCmd() {
+            if (this._synchedMotor)
+                this.clearSpeedCmd();
         }
 
         setLarge(large: boolean) {
@@ -179,11 +185,13 @@ namespace pxsim {
                     case DAL.opOutputStepSync:
                     case DAL.opOutputTimeSync: {
                         const otherMotor = this._synchedMotor;
-                        if (otherMotor.port < this.port) // handled in other motor code
-                            break;
-
                         const speed = this.speedCmdValues[0];
                         const turnRatio = this.speedCmdValues[1];
+                        // if turnratio is negative, right motor at power level
+                        // right motor -> this.port > otherMotor.port
+                        if (Math.sign(this.port - otherMotor.port)
+                            == Math.sign(turnRatio))
+                            break; // handled in other motor code
                         const stepsOrTime = this.speedCmdValues[2];
                         const brake = this.speedCmdValues[3];
                         const dstep = this.speedCmd == DAL.opOutputTimeSync
@@ -199,12 +207,7 @@ namespace pxsim {
 
                         // turn ratio is a bit weird to interpret
                         // see https://communities.theiet.org/blogs/698/1706
-                        if (turnRatio < 0) {
-                            otherMotor.speed = speed;
-                            this.speed *= (100 + turnRatio) / 100;
-                        } else {
-                            otherMotor.speed = this.speed * (100 - turnRatio) / 100;
-                        }
+                        otherMotor.speed = this.speed * (100 - Math.abs(turnRatio)) / 100;
 
                         // clamp
                         this.speed = Math.max(-100, Math.min(100, this.speed >> 0));

sim/state/output.ts

@@ -80,6 +80,12 @@ namespace pxsim {
                             const brake = pxsim.BufferMethods.getNumber(buf, BufferMethods.NumberFormat.Int8LE, 12);
 
                             const motors = ev3board().getMotor(port);
+                            // cancel any other sync command
+                            for(const motor of ev3board().getMotors().filter(motor => motors.indexOf(motor) < 0)) {
+                                motor.clearSyncCmd()
+                            }
+
+                            // apply commands to all motors
                             for (const motor of motors) {
                                 const otherMotor = motors.filter(m => m.port != motor.port)[0];
                                 motor.setSyncCmd(

targetconfig.json

@@ -16,6 +16,6 @@
         "Videos": "videos"
     },
     "electronManifest": {
-        "latest": "v1.0.8"
+        "latest": "v1.0.11"
     }
 }