0.2.161

will move select lessons back to "educators" section

.gitignore

@@ -1,9 +1,11 @@
 node_modules
+yotta_modules
+yotta_targets
 built
 typings
 tmp
 temp
-projects
+projects/**
 win10/app/bin
 win10/app/bld
 win10/*.opendb

README.md

@@ -1,7 +1,7 @@
 # micro:bit target for PXT
 
 This target allow to program a [BBC micro:bit](https://www.microbit.co.uk/) using 
-[Microsoft Programming Experience Toolkit](https://github.com/Microsoft/pxt).
+PXT ([Microsoft Programming Experience Toolkit](https://github.com/Microsoft/pxt)).
 
 * [Try it live](https://m.pxt.io)
 
@@ -24,13 +24,21 @@ npm install
 
 ### Running
 
-Run this command to open a local web server:
+Run this command to open a local web server (add ``sudo`` for Mac/Linux shells)
 ```
 pxt serve
 ```
-To make sure you're running the latest tools, run
+If the local server opens in the wrong browser, make sure to copy the URL containing the local token. 
+Otherwise, the editor will not be able to load the projects.
+
+If you need modify the `.cpp` files, turn on yotta compilation with the ``-yt`` flag (add ``sudo`` for Mac/Linux shells):
 ```
-npm update
+pxt serve -yt
+```
+
+To make sure you're running the latest tools, run (add ``sudo`` for Mac/Linux shells)
+```
+pxt update
 ```
 
 More instructions at https://github.com/Microsoft/pxt#running-a-target-from-localhost 
@@ -38,7 +46,7 @@ More instructions at https://github.com/Microsoft/pxt#running-a-target-from-loca
 ## Universal Windows App
 
 The Windows 10 app is a [Universal Windows Hosted Web App](https://microsoftedge.github.io/WebAppsDocs/en-US/win10/CreateHWA.htm)
-that wraps m.pxt.io and provides additional features.
+that wraps ``m.pxt.io`` and provides additional features.
 
 ### Building
 

cmds/tsconfig.json

@@ -8,6 +8,6 @@
         "module": "commonjs",
         "rootDir": ".",
         "newLine": "LF",
-        "sourceMap": true
+        "sourceMap": false
     }
 }

docs/about.md

@@ -31,15 +31,15 @@ Just like Arduino, the micro:bit can be connected to and interact with sensors,
 
 ## Blocks or JavaScript
 
-The student can program the BBC micro:bit using [visual blocks](http://www.github.com/Google/blockly) or JavaScript.
+The student can program the BBC micro:bit using Blocks or JavaScript.
 
 ```blocks
-basic.showString("BBC micro:bit!");
+basic.showString("Hi!");
 ```
 
 ## Compile and Flash
 
-When a user has her code ready, she can connect her BBC micro:bit to a computer via a USB cable, so it appears as a mounted drive.
+When a user has her code ready, she can connect her BBC micro:bit to a computer via a USB cable, so it appears as a mounted drive (named MICROBIT). 
 
 Compilation to the ARM thumb machine code happens in the browser.
 
@@ -47,6 +47,7 @@ The student is prompted to save the ARM binary program to a file, which she then
 which flashes the micro:bit device with the new program.
 
 ## Simulator: Test Your Code
+
 Before a student compiles her code for the micro:bit, she can run it using the micro:bit simulator, all within the confines of a web browser. 
 The simulator has support for the LED screen, buttons, as well as compass, accelerometer, and digital I/O pins.
 
@@ -54,5 +55,10 @@ The simulator has support for the LED screen, buttons, as well as compass, accel
 
 The [C++ BBC micro:bit runtime](http://lancaster-university.github.io/microbit-docs/), created at [Lancaster University](http://www.lancaster.ac.uk/), provides access to the hardware functions of the micro:bit, 
 as well as a set of helper functions (such as displaying a number/image/string on the LED screen). 
+
 The JavaScript micro:bit library mirrors the functions of the C++ library. 
 When code is compiled to ARM machine code, the calls to JavaScript micro:bit functions are replaced with calls to the corresponding C++ functions.
+
+## Open Source
+
+The editor for the BBC micro:bit is [open source](/open-source) on GitHub. Contributors are welcome!

docs/blocks.md

@@ -0,0 +1,8 @@
+# Blocks language
+
+```namspaces
+for (let i = 0;i<5;++i) {}
+if (true){}
+let x = 0;
+Math.random(5);
+```

docs/device.md

@@ -15,12 +15,14 @@ It flashes yellow when the system wants to tell the user that something has happ
 ### Buttons
 
 Buttons A and B are a form of input.  When you press a button, it completes an electrical circuit. 
-The micro:bit can detect either of its two buttons being pressed and un-pressed and be programmed 
-to act on that or send the information to another device.
+The micro:bit can detect either of its two buttons being pressed/released and be programmed 
+to act on these events.
 
 Button R on the back of the micro:bit is a system button. It has different uses. 
 When you have downloaded and run your code onto your micro:bit, press Button R to restart and run your program from the beginning.
 
+### USB connection
+
 When you plug in your micro:bit, it should appear as MICROBIT. 
 If you accidentally hold down the reset button as you’re plugging in your micro:bit, 
 the micro:bit will appear as a MAINTENANCE drive instead of MICROBIT. This is known as maintenance mode.**
@@ -43,7 +45,7 @@ This data can be used by the micro:bit in a program or be sent to another device
 
 ### Accelerometer
 
-There is a an accelerometer on your micro:bit which detects changes in the micro:bit’s speed. 
+There is an accelerometer on your micro:bit which detects changes in the micro:bit’s speed. 
 It converts analogue information into digital form that can be used in micro:bit programs. 
 Output is in milli-g. The device will also detect a small number of standard actions e.g. shake, tilt and free-fall.
 
@@ -75,7 +77,7 @@ The BBC micro:bit can send an receive data via [serial communication](/device/se
 
 ### Bluetooth Low Energy (BLE) Antenna
 
-You will see the label BLE ANNTENA on the back of your micro:bit. It is for a messaging service, 
+You will see the label BLE ANTENNA on the back of your micro:bit. It is for a messaging service, 
 so that devices can talk to each other. The micro:bit is a peripheral 
 device which can talk to a central device like a smart phone or tablet that has Bluetooth Low Energy (BLE). 
 The micro:bit can send signals and receive signals from a central device so another BLE device can 

docs/device/contents.md

@@ -1,7 +1,5 @@
 # micro:bit - the device
 
-The micro:bit device #docs
-
 The micro:bit is a very capable device with many components:
 
 * [the USB connector](/device/usb)

docs/device/crocodile-clips.md

@@ -11,12 +11,6 @@ This example displays a random number every time the crocodile clip holds  `GND`
 
 ### Connecting Crocodile Clips
 
-
-
-### Lessons
-
-[love meter](/lessons/love-meter)
-
 ### See also
 
 [micro:bit pins](/device/pins), [pin is pressed](/reference/input/pin-is-pressed), [analog read pin](/reference/pins/analog-read-pin), [analog write pin](/reference/pins/analog-write-pin), [digital read pin](/reference/pins/digital-read-pin), [digital write pin](/reference/pins/digital-write-pin)

docs/device/error-codes.md

@@ -1,6 +1,6 @@
 # Error codes
 
-The micro:bit error codes #docs
+The micro:bit error codes
 
 Your micro:bit may encounter a situation that prevents it from running your code. When this happens, a frowny face will appear on your micro:bit screen (see picture) followed by an error number.
 

docs/device/reactive.md

@@ -1,7 +1,5 @@
 # The micro:bit - a reactive system
 
-The micro:bit is a reactive system. #docs
-
 ### Computing systems
 
 What sort of a *computing system* is the micro:bit?

docs/device/screen.md

@@ -3,40 +3,61 @@
 The micro:bit LED screen 
 
 ```sim
-basic.showString(" ");
+    basic.showLeds(`
+        # . # . #
+        . # . # .
+        # . # . #
+        . # . # .
+        # . # . #
+        `);
 ```
 
 The micro:bit LED screen consists of 25 red LED lights arranged in a 5X5 grid (5 LEDs across by 5 LEDs down).
+In the screen above, we created a checkerboard pattern using the LEDs.
 
 ### Which LED?
 
-You use ``x , y`` coordinates to specify a particular LED in the grid; where ``x`` is the horizontal position and ``y`` is the vertical position (0, 1, 2, 3, 4). To figure out the ``x``, ``y`` coordinates, position your micro:bit horizontally, like a credit card (see picture above).
+You use `(x ,y)` coordinates to specify a particular LED in the grid; 
+where `x` is the horizontal position (0,1,2,3,4) and `y` is the vertical position 
+(0, 1, 2, 3, 4). 
+
+To figure out the ``x``, ``y`` coordinates, position your micro:bit horizontally, like a credit card (see picture above).
 
 Here are the x, y coordinates for the LEDs in the 5X5 grid:
 
-`0, 0` `1, 0` `2, 0` `3, 0` `4, 0`
+`(0,0)` `(1,0)` `(2,0)` `(3,0)` `(4,0)`
 
-`0, 1` `1, 1` `2, 1` `3, 1` `4, 1`
+`(0,1)` `(1,1)` `(2,1)` `(3,1)` `(4,1)`
 
-`0, 2` `1, 2` `2, 2` `3, 2` `4, 2`
+`(0,2)` `(1,2)` `(2,2)` `(3,2)` `(4,2)`
 
-`0, 3` `1, 3` `2, 3` `3, 3` `4, 3`
+`(0,3)` `(1,3)` `(2,3)` `(3,3)` `(4,3)`
 
-`0, 4` `1, 4` `2, 4` `3, 4` `4, 4`
+`(0,4)` `(1,4)` `(2,4)` `(3,4)` `(4,4)`
 
-The x, y coordinates for the LED in the centre of the grid are `2, 2`. Starting from `0, 0` count over 2 columns and then down 2 rows.
+The x, y coordinates for the LED in the centre of the grid are `(2,2)`. Starting from `(0,0)` count over 2 columns and then down 2 rows.
+
+### Check your understanding
+
+Which LEDs are turned on in the checkboard pattern above? 
 
 ### Row, column - 1
 
-Since the row and column numbers start at 0, an easy way to figure out the x, y coordinates is to subtract 1 from the row and column number (when counting from 1). In other words, to specify the LED in the 4th column 5th row, subtract 1 from each number to get coordinates `3, 4`.
+Since the row and column numbers start at 0, an easy way to figure out the (x,y) coordinates 
+is to subtract 1 from the row and column number (when counting from 1). 
+In other words, to specify the LED in the 4th column 5th row, subtract 1 from each number to get coordinates `(3,4)`.
 
 ### Turn a LED on/off
 
 Use [plot](/reference/led/plot) and [unplot](/reference/led/unplot) to turn a LED on or off
 
 ```blocks
-led.plot(0,0)
-led.unplot(0,0)
+led.plot(0,0);
+led.plot(1,1);
+basic.pause(1000);
+led.unplot(0,0);
+basic.pause(1000);
+led.unplot(1,1);
 ```
 
 ### Is a LED on/off?

docs/device/serial.md

@@ -11,16 +11,35 @@ input.onButtonPressed(Button.A, () => {
 })
 ```
 
+Data is also automatically streamed to serial by the ** bar graph** block
+and picked up by the editor. This data can be streamed to the cloud as well.
+
+```blocks
+basic.forever(() => {
+   led.plotBarGraph(input.acceleration(Dimension.X), 0);
+});
+```
+
 ## How to read the micro:bit's serial output from your computer
 
 Unfortunately, using the serial library requires quite a bit of a setup.
 
+### BBC micro:bit Chrome Extension
+
+If you are using the Google Chrome browser, you can use our extension to get serial data streaming in the editor.
+
+* Install the [Extension for BBC micro:bit](https://chrome.google.com/webstore/detail/extension-for-bbc-microbi/cihhkhnngbjlhahcfmhekmbnnjcjdbge?hl=en-US) on the Chrome Web Store.
+* Restart Chrome and open the web editor.
+
 ### Windows
 
 You must install a device driver (for the computer to recognize the serial interface of the micro:bit); then, you must also install a terminal emulator (which is going to connect to the micro:bit and read its output). Here's how to do it:
 
 * Follow instructions at https://developer.mbed.org/handbook/Windows-serial-configuration in order to install the device driver
-* Install a terminal emulator; we recommend [Tera Term](https://ttssh2.osdn.jp/index.html.en). At the time of this writing, the latest version is 4.88 and can be downloaded [from here](http://en.osdn.jp/frs/redir.php?m=jaist&f=%2Fttssh2%2F63767%2Fteraterm-4.88.exe). Follow the instructions from the installer.
+
+#### Windows > Tera Term
+
+* Install the terminal emulator [Tera Term](https://ttssh2.osdn.jp/index.html.en). At the time of this writing, the latest version is 4.88 and can be downloaded [from here](http://en.osdn.jp/frs/redir.php?m=jaist&f=%2Fttssh2%2F63767%2Fteraterm-4.88.exe). Follow the instructions from the installer.
 
 Once both the driver and the terminal emulator are installed, plug in the micro:bit and wait until the device is fully setup. Then, open TeraTerm.
 
@@ -32,7 +51,7 @@ You should be good. Feel free to hit `Setup` > `Save Setup` in the menus to eras
 
 Please note that Windows will assign you a different COM port if you plug in another micro:bit. If you're juggling between micro:bits, you'll have to change the COM port every time.
 
-### Alternative Windows setup with Putty
+#### Windows > Putty
 
 If you prefer another terminal emulator (such as [PuTTY](http://www.putty.org/)), here are some instructions.
 

docs/docs.md

@@ -25,9 +25,10 @@ input.onButtonPressed(Button.B, () => {
 ``` 
 
 * **[getting started](/getting-started)**
+* Get started with [projects](/projects)
 * Browse the [API reference](/reference)
 * Learn more about the [device](/device)
-* Get started with [lessons](/lessons)
+* Frequently Asked Question [faq](/faq)
 * Follow up with the [release notes](/release-notes)
 
 ### Developers

docs/faq.md

@@ -0,0 +1,6 @@
+# Frequently Asked Questions
+
+## Where can I get a BBC micro:bit?
+
+More information at [http://uk.farnell.com/bbc-microbit](http://uk.farnell.com/bbc-microbit).
+

docs/getting-started.md

@@ -1,36 +1,21 @@
 # Getting started
 
-Are you ready to build cool BBC micro:bit programs? For each challenge, reorder the blocks to recreate the program.
+## ~avatar
 
-## Open [https://m.pxt.io](/) and create a new **Blocks Editor** project
+Are you ready to build cool BBC micro:bit programs?
 
-## Basic
+Here are some challenges for you. Unscramble the blocks in the editor
+to make real programs that work!
 
-### Show leds
+## ~
 
-Use the blocks below to draw a figure on the screen. You can redo the smiley face or try something else!
+### Happy face
 
-```shuffle
-basic.showLeds(`
-    . . . . .
-    . # . # .
-    . . . . .
-    # . . . #
-    . # # # .
-    `)
-```
-
-To transfer your code to the BBC micro:bit, 
-* connect your micro:bit to the computer using the USB cable
-* click on **Download**
-* drag&drop the **.hex** file into the **MICROBIT** drive
-* wait till the yellow light is done blinking!
-
-### Show animation Forever
-
-Show one image after the other to create an animation by snapping them together.
+There are three blocks in the editor (the area to the left).
+They should look like this:
 
 ```blocks
+basic.forever(() => {
     basic.showLeds(`
         . . . . .
         . # . # .
@@ -40,20 +25,29 @@ Show one image after the other to create an animation by snapping them together.
         `)
     basic.showLeds(`
         . . . . .
-        . # . # .
         . . . . .
-        . # # # .
-        # . . . #
+        . . . . .
+        . . . . .
+        . . . . .
         `)
+});
 ```
 
+When you run this program, you will see a smiley face, then a blank
+screen, then a smiley again -- it never stops! (That's because of the
+``forever`` block.)
 
-### Repeat forever
+Click **Compile** to move your program to the BBC micro:bit!
 
-Use the ``forever`` block to repeat your code and have a continuous animation.
+### Happy unhappy face
 
-Unsuffle the blocks to create a happy, unhappy animation.... or changes the image to make it your own!
-```shuffle
+Draw an unhappy face instead of the blank screen.  Click on the dots
+in the second ``show leds`` block until it matches the blocks below.
+Now you have an **animation** (cartoon) that shows a happy face,
+then an unhappy one, then a happy one again, forever (or until
+you turn off your micro:bit)!
+
+```blocks
 basic.forever(() => {
     basic.showLeds(`
         . . . . .
@@ -71,40 +65,117 @@ basic.forever(() => {
         `)
 });
 ```
+Click **Compile** to move your program to the BBC micro:bit!
 
-### Your turn now!
+### Your turn!
 
-Use the blocks ``show leds`` and ``forever``
-to create your own custom awesome animation!
+Pile up more ``show leds`` blocks to create your animation! Create an
+animation with at least 5 pictures.  What does this animation show?
 
-## Inputs
+```blocks
+basic.forever(() => {
+    basic.showLeds(`
+        . . . . .
+        . # . # .
+        . . . . .
+        # . . . #
+        . # # # .
+        `)
+    basic.showLeds(`
+        . . . . .
+        . # . # .
+        . . . . .
+        # # # # #
+        . . . . .
+        `)
+    basic.showLeds(`
+        . . . . .
+        . # . # .
+        . . . . .
+        . # # # .
+        # . . . #
+        `)
+    basic.showLeds(`
+        . . . . .
+        . # . # .
+        . . . . .
+        # # # # #
+        . . . # #
+        `)
+    basic.showLeds(`
+        . . . . .
+        # . # . .
+        . . . . .
+        # . . . #
+        . # # # .
+        `)
+    basic.showLeds(`
+        . . . . .
+        . . # . #
+        . . . . .
+        # . . . #
+        . # # # .
+        `)
+});
+```
+Click **Compile** to move your program to the BBC micro:bit!
 
-### Button A and B
+#### ~hint
 
-Unshuffle the blocks so that the micro:bit shows "YES" when button A is pressed, and "NO" when B is pressed. 
-The key idea is that all the blocks nested under `on button ... pressed` will run when that button is pressed.
+You can find the ``show leds`` block in the **Basic** part of the editor.
+
+#### ~
+
+### Button A and button B
+
+This program will show the word **ANTEATER** on the LED
+screen when you press button `A`.
 
 ```blocks
 input.onButtonPressed(Button.A, () => {
-    basic.showString("AAAAA");
+    basic.showString("ANTEATER");
 });
 ```
 
-Try to unshuffle those blocks:
+#### ~hint
+
+The ``showString`` block can show letters, numbers, and punctuation
+on the micro:bit screen.
+
+#### ~
+
+Now try to unscramble these blocks in the editor so that the micro:bit
+shows **BANANA** when you press button `B`.
+
 ```shuffle
-input.onButtonPressed(Button.A, () => {
-    basic.showString("YES");
-});
 input.onButtonPressed(Button.B, () => {
-    basic.showString("NO");
+    basic.showString("BANANA");
 });
 ```
+#### ~hint
+
+You can find the letter `B` by clicking the letter `A` on the
+``onButtonPressed`` block.
+
+#### ~
+
+Click **Compile** to move your program to the BBC micro:bit!
+
+#### Your turn!
+
+Can you combine these blocks so your program shows your real name
+instead of **ANTEATER** when you press `A`, but _your secret agent
+name_ instead of **BANANA** when you press `B`?
 
 ### Shake
 
-Using the data from the **accelerometer**, it is possible to detect that the BBC micro:bit is being shaken.
+You can find when someone is shaking the BBC micro:bit by checking its
+**accelerometer** (it finds whether the micro:bit is speeding up or
+slowing down).
+
+Unscramble these blocks in the editor to show a frownie when someone
+shakes the micro:bit. (Ouch!)
 
-Unshuffle the code to display a frownie when shaken.
 ```shuffle
 input.onGesture(Gesture.Shake, () => {
     basic.showLeds(`
@@ -115,57 +186,317 @@ input.onGesture(Gesture.Shake, () => {
 # . . . #`);
 });
 ```
+Click **Compile** to move your program to the BBC micro:bit!
 
-### Tilting
+### Pins
 
-Aside from shake, it is also possible to detect tilt left and right, logo up and down or face up and down.
-Let's build a rock paper scissors game where you turn the micro:bit left to display paper, right to display scissors and down to display rock.
+You can also use the pins as buttons.  (The pins are the holes in the
+metal stripe at the bottom of the micro:bit board.)  For example, hold
+the ``GND`` button with one hand and touch the ``0`` pin (called
+``P0``) with your other hand to tell the micro:bit you're pressing it.
+
+Unscramble the blocks in the editor to show a heart when you touch
+pin ``P0``.
 
-Unshuffle and try this code on the micro:bit itself!
 ```shuffle
-input.onGesture(Gesture.TiltLeft, () => {
+input.onPinPressed(TouchPin.P0, () => {
+    basic.showLeds(`
+. # . # .
+# . # . #
+# . . . #
+. # . # .
+. . # . .`);
+});
+```
+Click **Compile** to move your program to the BBC micro:bit!
+
+## ~hint
+
+Try this experiment: find a friend and hold hands. Touch the ``GND``
+pin while your friend presses the ``P0`` pin. You should see the
+heart! The electric current is going through your bodies and across
+your handshake to make it happen!
+
+## ~
+
+## The amazing coin flipper
+
+### ~avatar avatar
+
+Are you trying to choose whether to play soccer or go to the movies
+instead, or which toppings to have on your pizza?  Build a coin
+flipping machine with the BBC micro:bit to choose for you!
+
+### ~
+
+Here are the blocks to make your coin flipper.  When you press button
+`B`, the coin flipper will show either `H` for heads or `T` for tails
+on the LED screen.
+
+```blocks
+input.onButtonPressed(Button.B, () => {
+    if (Math.randomBoolean()) {
+        basic.showString("H");
+    } else {
+        basic.showString("T");
+    }
+});
+```
+### ~hint
+
+The ``pick random true or false`` block randomly tells the ``if``
+block `true` or `false`.  If the ``pick`` block picked `true`, the
+``if`` block shows the letter `H`. Otherwise, it shows the letter `T`.
+
+That's it!
+
+### ~
+
+### Keeping score
+
+#### ~avatar
+
+To keep track out of how many guesses you've won,
+add these blocks to your coin flipper:
+
+#### ~
+
+```blocks
+input.onButtonPressed(Button.A, () => {
+    game.addScore(1);
+});
+input.onButtonPressed(Button.AB, () => {
+    basic.showNumber(game.score());
+});
+```
+
+These blocks mean that if you press button `A`, you will add `1` to
+your score, and if you press `A` and `B` together, the micro:bit will
+show your score.
+
+When you're done, your coin flipping program should look like this:
+
+```blocks
+input.onButtonPressed(Button.B, () => {
+    if (Math.randomBoolean()) {
+        basic.showString("H");
+    } else {
+        basic.showString("T");
+    }
+});
+input.onButtonPressed(Button.A, () => {
+    game.addScore(1);
+});
+input.onButtonPressed(Button.AB, () => {
+    basic.showNumber(game.score());
+});
+```
+
+Flip until your thumbs get tired!
+
+## Let's play Rock Paper Scissors!
+
+### ~avatar avatar
+
+Build a Rock Paper Scissors game with the BBC micro:bit!  You can play
+the game with a friend who has it on a micro:bit.  You can also play
+it with friends who are just using their hands.  (The game is built
+like a coin flipper, but with three choices instead of two.)
+
+### ~
+
+## Step 1: Getting started
+
+We want the micro:bit to choose rock, paper, or scissors when you
+shake it.  Try creating an ``on shake`` block so when you shake the
+micro:bit, it will run part of a program.
+
+Clear up the blocks and add the blocks below.
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    
+})
+```
+
+Next, when you shake the micro:bit, it should pick a random number from `0` to `2`
+and store it in the variable `item`.
+
+Add a ``set`` block with a variable. Then add a ``pick random`` block,
+and store the random number in the variable,
+like this:
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    let item = Math.random(3)
+})
+
+```
+
+### ~hint
+No one can predict random numbers. That's what makes them great for Rock Paper Scissors!
+### ~
+
+Each possible number these blocks can make (`0`, `1`, or `2`) means a different picture.
+We will show the right picture for that number on the LED screen.
+
+
+## Step 2: Picking paper
+
+Put an ``if`` block after the ``let`` block that checks whether
+`item` is `0`. Make sure the ``if`` block has an ``else if`` part
+and an ``else`` part.
+
+Next, add a ``show leds`` block that shows a
+picture of a piece of paper:
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    let item = Math.random(3)
+    if (item == 0) {
         basic.showLeds(`
             # # # # #
             # . . . #
             # . . . #
             # . . . #
-# # # # #`);
-});
-input.onGesture(Gesture.LogoDown, () => {
+            # # # # #
+            `)
+    } else if (false) {
+
+    } else {
+
+    }
+})
+```
+
+## Step 3: A random rock
+
+Now we are going to add a new picture for the micro:bit to show
+when another random number comes up.
+
+Make the ``else if`` part check if the variable `item` is `1`.
+Then add a ``show leds`` block with a picture of a rock.
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    let item = Math.random(3)
+    if (item == 0) {
+        basic.showLeds(`
+            # # # # #
+            # . . . #
+            # . . . #
+            # . . . #
+            # # # # #
+            `)
+    } else if (item == 1) {
         basic.showLeds(`
             . . . . .
             . # # # .
             . # # # .
             . # # # .
-. . . . .`);
-});
-input.onGesture(Gesture.TiltRight, () => {
+            . . . . .
+            `)
+    } else {
+
+    }
+})
+```
+
+## Step 4: Suddenly scissors
+
+Add a ``show leds`` block with a picture of scissors to the ``else`` part:
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    let item = Math.random(3)
+    if (item == 0) {
+        basic.showLeds(`
+            # # # # #
+            # . . . #
+            # . . . #
+            # . . . #
+            # # # # #
+            `)
+
+    } else if (item == 1) {
+        basic.showLeds(`
+            . . . . .
+            . # # # .
+            . # # # .
+            . # # # .
+            . . . . .
+            `)
+    } else {
         basic.showLeds(`
             # # . . #
             # # . # .
             . . # . .
             # # . # .
-# # . . #`);
-});
+            # # . . #
+            `)
+    }
+})
+
 ```
 
-### Pins
+### ~hint
 
-It is possible to use the pins (big metal bar at the bottom of the board) as button. Hold the ``GND`` button with one hand and press the ``0`` pin 
-(called ``P0``) with the other hand to trigger a pin pressed.
+You don't need to check if `item` is `2` because `2` is the only number left out of `0`, `1`, and `2`.
+That's why you can use an ``else`` instead of an ``else if``.
+
+### ~
+
+Your game is ready!
+
+Click **Compile** to move your program to the BBC micro:bit!
+
+Have fun!
+
+## Step 5: Are you the greatest?
+
+Here is a way you can make your Rock Paper Scissors game better.
+When button ``A`` is pressed, 
+the micro:bit will add `1` to your score.
+
+Open the ``Game`` drawer, and then add the block ``change score by 1`` to your program,
+like this:
+
+```blocks
+input.onButtonPressed(Button.A, () => {
+    game.addScore(1)
+})
+
+```
+
+## Step 6: Prove you're the greatest!
+
+After your micro:bit can add `1` to the score, show how many wins you have.
+
+```blocks
+input.onButtonPressed(Button.A, () => {
+    game.addScore(1)
+    basic.showString("WINS:")
+    basic.showNumber(game.score())
+})
+```
+## Step 7: Staying honest
+
+Success! Your micro:bit can track wins!
+But what about losses? 
+Use the ``Game`` drawer to subtract `1` from your score when you press button `B`. 
+
+Here are all the blocks you will need:
 
-Unshuffle the blocks to display a smiley when pin ``P0`` is pressed.
 ```shuffle
-input.onPinPressed(TouchPin.P0, () => {
-    basic.showLeds(`
-. . . . .
-. # . # .
-. . . . .
-# . . . #
-. # # # .`);
-});
+input.onButtonPressed(Button.B, () => {
+    game.addScore(-1)
+    basic.showString("LOSSES:")
+    basic.showNumber(game.score())
+})
 ```
+Click **Compile** to move your program to the BBC micro:bit!
 
-### Your turn now!
+## Your turn!
 
-Use the scree, buttons, gestures, pins to create a fun game using the micro:bit.
+How else can you make your game better?
+Ever hear of [Rock Paper Scissors Spock Lizard](http://www.samkass.com/theories/RPSSL.html)?

docs/lessons/banana-keyboard.md

@@ -1,21 +0,0 @@
-# banana keyboard blocks lesson
-
-display beautiful images on the BBC micro:bit.
-
-## Topic
-
-Music
-
-## Quick Links
-
-* [activity](/lessons/banana-keyboard/activity)
-
-## Prior learning/place of lesson in scheme of work
-
-Learn how to convert your BBC micro:bit into a music player using pins P0 and GND, earphones (or speakers), as well as crocodile clips (or spring clips). The connect fruit using pins P1 and GND.
-
-## Objectives
-
-* learn how to setup the BBC micro:bit with earphones to play music
-* learn how to setup the BBC micro:bit with fruit be the musical instrument
-

docs/lessons/hack-your-headphones.md

@@ -1,20 +0,0 @@
-# hack your headphones lesson
-
-display beautiful images on the BBC micro:bit.
-
-## Topic
-
-Hack your headphone
-
-## Quick Links
-
-* [activity](/lessons/hack-your-headphones/activity)
-
-## Prior learning/place of lesson in scheme of work
-
-Learn how to convert your BBC micro:bit into a music player using pins P0 and GND, headphones (or speakers), as well as crocodile clips (or spring clips).
-
-## Objectives
-
-* learn how to setup the BBC micro:bit with headphones to play music
-

docs/lessons/light-beatbox.md

@@ -1,21 +0,0 @@
-# light beatbox 
-
-display beautiful images on the BBC micro:bit.
-
-## Topic
-
-Music
-
-## Quick Links
-
-* [activity](/lessons/light-beatbox/activity)
-
-## Prior learning/place of lesson in scheme of work
-
-Learn how to make a light beatbox music player using the light sensor. We will be learning how to code musical notes using light level, a local variable, conditionals, on button pressed as well as simple commands such as ring tone and rest.
-
-## Objectives
-
-* learn how to control the light sensor on the BBC micro:bit
-* learn how to code music on the BBC micro:bit
-

docs/lessons/rock-paper-scissors.md

@@ -1,64 +0,0 @@
-# rock paper scissors lesson
-
-a game against the BBC micro:bit.
-
-### @video td/videos/rock-paper-scissors-0
-
-## Topic
-
-Local Variables
-
-## Quick Links
-
-* [activity](/lessons/rock-paper-scissors/activity)
-* [challenges](/lessons/rock-paper-scissors/challenges)
-
-## Class
-
-Year 7
-
-## Prior learning/place of lesson in scheme of work
-
-Learn how to create a **local variable**, `var t :=time` where you can store data, so that you can use it in your code. We will be learning how to create a classic rock paper scissors game using global variables, input on shake, local variables, math random as well as simple commands such as create image, show image, show string, and show number.
-
-## Documentation
-
-```cards
-input.onGesture(Gesture.Shake, () => {})
-Math.random(3)
-let x = 0
-basic.showLeds(`
-    . . . . .
-    . . . . .
-    . . # . .
-    . . . . .
-    . . . . .
-    `)
-```
-
-## Objectives
-
-* learn how to create a condition so the micro:bit will run code when it is shaken
-* learn how to create a local variable for a place where you can store data
-* learn how to create an image to show on the micro:bit's LED screen
-* learn how to show an image on the micro:bit's LED screen
-
-## Progression Pathways / Computational Thinking Framework
-
-#### Algorithms
-
-* Uses diagrams to express solutions.(AB)
-* Represents solutions using a structured notation (AL) (AB)
-
-#### Programming & Development
-
-* Creates programs that implement algorithms to achieve given goals (AL)
-*  Declares and assigns variables(AB)
-* Selects the appropriate data types(AL) (AB
-
-#### Data & Data Representation
-
-* Defines data types: real numbers and Boolean (AB)
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-

docs/lessons/rock-paper-scissors/activity.md

@@ -1,121 +0,0 @@
-# rock paper scissors activity
-
-A classic game against the micro:bit.
-
-### ~avatar avatar
-
-### @video td/videos/rock-paper-scissors-0
-
-Welcome! This tutorial will help you create a game of rock paper scissors with the micro:bit. Let's get started!
-
-### ~
-
-We want the micro:bit to choose rock, paper, or scissors when it is shaken. Let's begin by creating an on shake condition so the micro:bit will run code when it is shaken.
-
-
-```blocks
-
-input.onGesture(Gesture.Shake, () => {
-    
-})
-
-```
-
-Next, create a variable and store pick random number from 0 to 2.  On shake, a number will be randomly picked from 0-2. We will randomly display an image based on the random number returned.
-
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(3)
-})
-
-```
-
-The micro:bit will look like it's showing 1 frame of the image by displaying the whole image when pick random is equal to 2. We can help the micro:bit randomly decide which image to use by pick random. The micro:bit will randomly pick the image to display with show LEDs and the pick random function.
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(3)
-    if (img == 2) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
-
-    }
-})
-
-
-```
-
-The micro:bit will look like it's showing 1 frame of the image by displaying the whole image when pick random is equal to 1. We can help the micro:bit randomly decide which image to use by pick random. The micro:bit will randomly pick the image to display with show LEDs and the pick random function.
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(3)
-    if (img == 2) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
-
-    } else if (img == 1) {
-        basic.showLeds(`
-            . . . . .
-            . # # # .
-            . # # # .
-            . # # # .
-            . . . . .
-            `)
-    }
-})
-```
-
-The micro:bit will look like it's showing 1 frame of the image by displaying the whole image when pick random is not equal to 2 and not equal to 1. We can help the micro:bit randomly decide which image to use by pick random. The micro:bit will randomly pick the image to display with show LEDs and the pick random function.
-
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(3)
-    if (img == 2) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
-
-    } else if (img == 1) {
-        basic.showLeds(`
-            . . . . .
-            . # # # .
-            . # # # .
-            . # # # .
-            . . . . .
-            `)
-    } else {
-        basic.showLeds(`
-            . . . # #
-            # # . # .
-            . . # . .
-            # # . # .
-            . . . # #
-            `)
-    }
-})
-
-```
-
-### ~avatar avatar
-
-Excellent, you're ready to continue with the [challenges](/lessons/rock-paper-scissors/challenges)!
-
-### ~
-

docs/lessons/rock-paper-scissors/challenges.md

@@ -1,133 +0,0 @@
-# rock paper scissors challenges
-
-Coding challenges for rock paper scissors. 
-
-## Before we get started
-
-Complete the following [guided activity](/lessons/rock-paper-scissors/activity) , your code should look like this:
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(3)
-    if (img == 2) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
-
-    } else if (img == 1) {
-        basic.showLeds(`
-            . . . . .
-            . # # # .
-            . # # # .
-            . # # # .
-            . . . . .
-            `)
-    } else {
-        basic.showLeds(`
-            . . . # #
-            # # . # .
-            . . # . .
-            # # . # .
-            . . . # #
-            `)
-    }
-})
-
-```
-
-### Challenge 1
-
-When the A button is pressed, increment the score by 1. You can select Game drawer then add change score by 1.
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(2)
-    if (img == 2) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
-
-    } else if (img == 1) {
-        basic.showLeds(`
-            . . . . .
-            . # # # .
-            . # # # .
-            . # # # .
-            . . . . .
-            `)
-    } else {
-        basic.showLeds(`
-            . . . # #
-            # # . # .
-            . . # . .
-            # # . # .
-            . . . # #
-            `)
-    }
-})
-input.onButtonPressed(Button.A, () => {
-    game.addScore(1)
-})
-
-```
-
-* Click *run* to execute your code in the simulator
-
-### Challenge 2
-
-After incrementing the score, display the total number of wins you have.
-
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(2)
-    if (img == 2) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
-
-    } else if (img == 1) {
-        basic.showLeds(`
-            . . . . .
-            . # # # .
-            . # # # .
-            . # # # .
-            . . . . .
-            `)
-    } else {
-        basic.showLeds(`
-            . . . # #
-            # # . # .
-            . . # . .
-            # # . # .
-            . . . # #
-            `)
-    }
-})
-input.onButtonPressed(Button.A, () => {
-    game.addScore(1)
-    basic.showString("WINS:")
-    basic.showNumber(game.score())
-})
-
-```
-
-* Run and compile the code to see if it works as expected.
-
-### Challenge 3
-
-You have successfully tracked and displayed the number of wins on the micro:bit! However, what about losses? Use the Game drawer to change score by -1 when button `B` is pressed.
-
-* Run and compile the code to see if it works as expected.

docs/lessons/rock-paper-scissors/quiz.md

@@ -1,74 +0,0 @@
-# rock paper scissors quiz
-
-shift an image horizontally across the display with offset.
-
-## Name
-
-## Directions
-
-Use this activity document to guide your work in the [rock paper scissors tutorial](/lessons/rock-paper-scissors/activity).
-
-Answer the questions while completing the tutorial. Pay attention to the dialogues!
-
-## 1. Describe what `offset` does? 
-
-<br/>
-
-## 2. Draw which LEDs are ON after running this code and the random number returned is 0
-
-```blocks
-let img = images.createImage(`
-. . . . . # # # # # . . . . #
-. # # # . # . . . # # # . # .
-. # # # . # . . . # . # # . .
-. # # # . # . . . # # # . # .
-. . . . . # # # # # . . . . #
-`)
-let offset = Math.random(3) * 5
-img.showImage(offset)
-```
-
-![](/static/mb/lessons/night-light-2.png)
-
-<br/>
-
-<br/>
-
-## 3. Draw which LEDs are ON after running this code with an offset of 5. This would occur if the random number returned is 1.
-
-```blocks
-let img_ = images.createImage(`
-. . . . . # # # # # . . . . #
-. # # # . # . . . # # # . # .
-. # # # . # . . . # . # # . .
-. # # # . # . . . # # # . # .
-. . . . . # # # # # . . . . #
-`)
-let offset_ = Math.random(3) * 5
-img.showImage(offset)
-```
-
-![](/static/mb/lessons/night-light-2.png)
-
-<br/>
-
-<br/>
-
-## 4. Draw which LEDs are ON after running this code with an offset of 10. This would occur if the random number returned is 2.
-
-```blocks
-let img_1 = images.createImage(`
-. . . . . # # # # # . . . . #
-. # # # . # . . . # # # . # .
-. # # # . # . . . # . # # . .
-. # # # . # . . . # # # . # .
-. . . . . # # # # # . . . . #
-`)
-let offset_1 = Math.random(3) * 5
-img.showImage(offset)
-```
-
-![](/static/mb/lessons/night-light-2.png)
-
-<br/>
-

docs/lessons/seismograph/activity.md

@@ -1,150 +0,0 @@
-# Seismograph Activity 
-
-### ~avatar avatar
-
-In this project, you will build your own seismograph. 
-
-## What you'll need: 
-
-* micro:bit 
-* USB cable
-* Scissors
-* Glue gun
-* String
-* Cup (Plastic or Paper)
-* Magnet
-
-Welcome! This activity will teach how to use the micro:bit to chart the strength of the acceleration. Let's get started!
-
-1. Setup Cup: Use scissors to cut a usable window on the cup, which will be a square sized hole at the lid side of the cup. Use scissors to create a small hole in the center of the base of the cup. 
-
-2. Fasten Magnet: Fasten end of the string to the magnet with glue
-
-3. Secure String: Fasten string to base of the cup and hang the remaining string outside the base of the cup. 
-
-### ~avatar avatar
-
-Seismograph built, let's code! 
-
-### ~
-
-4. Go to Codemicrobit.com
-
-    Click or tap Create Code
-    Click or tap Block Editor
-    
-### ~
-
-5. 
-
-We will measure `acceleration (mg)` in terms of strength. Get the acceleration value (milli g-force), as measured in strength.
-
-```blocks
-input.acceleration(Dimension.Strength);
-```
-
-### ~
-
-6. 
-
-Use the plot bar chart to visualize the acceleration on the LED screen of the micro:bit in the specified range. You implement plot Bar Graph to display a vertical bar graph based on the "value" and "high" value. Then you must insert acceleration in based on strength. 
-
-```blocks
-basic.forever(() => {
-    led.plotBarGraph(input.acceleration(Dimension.Strength), 0);
-});
-
-```
-
-### ~
-
-7. 
-
-Finally, we subtract the gravity from acceleration strength. 
-
-```blocks
-basic.forever(() => {
-    led.plotBarGraph(input.acceleration(Dimension.Strength) - 1023, 0);
-});
-
-```
-
-### ~
-
-8. 
-
-Notice that making vibrating the object below the micro:bit changes the values and the line appears as a wave to display the value of the strength as measured in milli-gravities. By making the object below the micro:bit vibrate, you will observe changing values of the micro:bit. Also, the LEDs shown on the Bar Graph fluctates based on the movement of the micro:bit strength. 
-
-NOTE: The black color reflects the micro:bit device. 
-
-![](/static/mb/data4.png)
-
-
-### ~
-
-9. 
- 
-Vigorously move the micro:bit in the micro:bit simulatator by moving the micro:bit image from side to side. Every time the micro:bit moves in the x direction in the simulator,  you are generating data points that can be reviewed in Excel. The more attempts to move the micro:bit from side to side, the more data being saved in Excel. After you have vigarously moved the micro:bit simulator from side to side for a sufficient amount of time, you are ready to graph or chart the accceleration of the micro:bit. We want a printout of our acceleration on Excel that can be graphed in Excel. 
-
-
-### ~
-
-10. 
-
-We want to chart the data collected by using a tool in Excel. 
-
-The final part of this experiment is opening and reviewing the data in the Excel CSV file. Simply click on the line beneath the simulator. A CSV file will be generated to display the data points collected by moving the micro:bit in the X direction. Then click or tap on the data Excel file that was downloaded to your local Downloads Folder. 
-
-
-### ~
-
-10. 
-
-
-First, click or tap on the first two columns (A, B) to  include the time of the data being collected; b) the results of acceleration data on the micro:bit  
-
-![](/static/mb/data7.png)
-
-Use the Recommended Charts command on the Insert tab to quickly create a chart that’s just right for your data.
-
-* Select the data that you want to include in your chart.
-
-* Click Insert > Recommended Charts.
-
-### ~
-
-11. 
-
-
-![](/static/mb/chart1.png)
-
-* On the Recommended Charts tab, scroll through the list of chart types that Excel recommends for your data.
-
-Click any chart type to see how your data will look in that format. 
-
-When you find the chart type that you want, click it, and then click OK. We want to select the chart called Line. A line chart is used to display trends over time. We will use the line chart because there are many data points over time. 
-
-Tip: If you don’t see a chart type that you want, click the All Charts tab to see all of the available chart types.
-
-### ~
-
-12. 
-
-![](/static/mb/chart_title.png)
-
-* Use the Chart Elements, Chart Styles, and Chart Filters buttons next to the upper-right corner of the chart to add chart elements like axis titles or data labels, to customize the look of your chart
-
-### ~
-
-13. 
-
-![](/static/mb/elements_styles_filters.png)
-
-* Connect a micro:bit to your computer using your USB cable; compile; and repeat this experiment by vibrating the micro:bit. Then chart the data on Excel. 
-
-### ~avatar avatar
-
-Excellent, you're ready to continue with the [challenges](/lessons/seismograph/challenge)
-
-### ~
-

docs/lessons/telegraph.md

@@ -1,23 +0,0 @@
-# telegraph lesson
-
-display beautiful images on the BBC micro:bit.
-
-## Topic
-
-Telegraph
-
-## Quick Links
-
-* [activity](/lessons/telegraph/activity)
-* [challenges](/lessons/telegraph/challenges)
-
-
-## Prior learning/place of lesson in scheme of work
-
-Learn how to convert your BBC micro:bit into a telegraph using a second BBC micro:bit as well as pin P1, P2, 3V, GND, and crocodile clips (or spring clips). The connect BBC micro:bit uses pins P1, P2, 3V, GND.
-
-## Objectives
-
-* learn how to setup the BBC micro:bit with crocodile clips
-* learn how to telegraph to another BBC micro:bit
-

docs/lessons/the-watch.md

@@ -1,23 +0,0 @@
-# the watch lesson
-
-display beautiful images on the BBC micro:bit.
-
-![](/static/mb/lessons/the-watch-0.png)
-
-## Topic
-
-The Watch
-
-## Quick Links
-
-* [activity](/lessons/the-watch/activity)
-
-
-
-## Prior learning/place of lesson in scheme of work
-
-Learn how to design the BBC micro:bit watch with household supplies.
-
-## Objectives
-
-* learn how to design and make the watch with the BBC micro:bit

docs/open-source.md

@@ -4,6 +4,6 @@ The editor is open source on GitHub under the MIT license. Contributions are wel
 
 ### Repos
 
+* [microsoft/pxt-microbit](https://github.com/Microsoft/pxt-microbit), PXT target for BBC micro:bit, also includes the documentation.
 * [microbit/pxt](https://github.com/Microsoft/pxt), programming experience toolkit (PXT)
-* [microsoft/pxt-microbit](https://github.com/Microsoft/pxt-microbit), PXT target for BBC micro:bit
 * [microsoft/pxt-microbit-core](https://github.com/Microsoft/pxt-microbit-core), Yotta module used to build the BBC micro:bit runtime

docs/packages.md

@@ -10,5 +10,39 @@ to a microbit.
 
 ## Finding libraries
 
+From the editor, the user clicks on **More** then **Add Package** and searches for the package. 
+
+To see the list of packages, click on **More** then **Show Files** to see the project file list.
+
+To remove a package, click on the garbage button in the file list next to the package.
+
 ## Publishing libraries
 
+Packages can be published from the pxt command line. We are still sorting out the details.
+
+## Localizing libraries
+
+It is possible to package localization strings for the **jsDoc** description associated to the API in the package.
+
+When compiling a package, the PXT compiler generates a `strings.json` file under the `_locales/` folder. 
+This file contains a map from the symbol name to the en
+
+```
+{
+  ...
+  "basic": "Provides access to basic micro:bit functionality.",
+   ...
+}
+```
+
+```
+{
+  "basic.clearScreen": "Eteint toutes les diodes."
+}
+```
+
+```
+_locales/
+_locales/fr/strings.json
+_locales/pt-BR/strings.json
+```

docs/projects.md

@@ -0,0 +1,46 @@
+# Projects
+
+![](/static/mb/projects/all10.png)
+
+## [Flashing Heart](/projects/flashing-heart)
+
+![](/static/mb/projects/a1-display.png)
+
+## [Smiley Buttons](/projects/smiley-buttons)
+
+![](/static/mb/projects/a2-buttons.png)
+
+## [Love Meter](/projects/love-meter)
+
+![](/static/mb/projects/a3-pins.png)
+
+## [Rock Paper Scissors](/projects/rock-paper-scissors)
+
+![](/static/mb/projects/a4-motion.png)
+
+## [Compass](/projects/compass)
+
+![](/static/mb/projects/a5-compass.png)
+
+## [Hack your headphones](/projects/hack-your-headphones)
+
+![](/static/mb/projects/a6-music.png)
+
+## [Banana keyboard](/projects/banana-keyboard)
+
+![](/static/mb/projects/a7-conductive.png)
+
+## [Telegraph](/projects/telegraph)
+
+![](/static/mb/projects/a8-network.png)
+
+## [Radio](/projects/radio)
+
+![](/static/mb/projects/a9-radio.png)
+
+## [Watch](/projects/the-watch)
+
+![](/static/mb/projects/a10-watch.png)
+
+
+

docs/projects/banana-keyboard.md

@@ -95,6 +95,6 @@ Tap your banana instrument to play sound against... the fruit!
 
 ### ~avatar boothing
 
-Excellent, you're ready to continue with the [challenges](/lessons/banana-keyboard/challenges)!
+Excellent, you're ready to continue with the [challenges](/banana-keyboard-challenges)!
 
 ### ~

docs/projects/compass.md

@@ -0,0 +1,112 @@
+# compass
+
+![](/static/mb/projects/a5-compass.png)
+
+Display the direction that the micro:bit is facing using the compass 
+
+### ~avatar avatar
+
+Welcome! This guided tutorial will show you how to program a script that displays the direction the micro:bit is pointing. Let's get started!
+
+### ~
+
+
+## Step 1
+
+Create a loop that will continuously update the reading of the compass.
+
+
+```blocks
+basic.forever(() => {
+    
+})
+```
+
+## Step 2
+
+Store the reading of the micro:bit in a variable called `degrees`.
+
+```blocks
+basic.forever(() => {
+    let degrees = input.compassHeading()
+})
+```
+
+## Step 3
+
+If `degrees` is less than `45`, then the compass heading is mostly pointing toward North. Display `N` on the micro:bit.
+
+```blocks
+basic.forever(() => {
+    let degrees = input.compassHeading();
+    if (degrees < 45) {
+        basic.showString("N");
+    }
+});
+```
+
+## Step 4
+
+If `degrees` is less than 135, the micro:bit is mostly pointing East. Display `E` on the micro:bit.
+
+
+```blocks
+basic.forever(() => {
+    let degrees = input.compassHeading();
+    if (degrees < 45) {
+        basic.showString("N");
+    }
+    else if (degrees < 135) {
+        basic.showString("E");
+    }
+});
+```
+
+## Step 5
+
+If `degrees` is less than 225, the micro:bit is mostly pointing South. Display `S` on the micro:bit.
+
+
+```blocks
+basic.forever(() => {
+    let degrees = input.compassHeading();
+    if (degrees < 45) {
+        basic.showString("N");
+    }
+    else if (degrees < 135) {
+        basic.showString("E");
+    }
+    else if (degrees < 225) {
+        basic.showString("S");
+    }
+});
+```
+
+## Step 6
+
+If none of these conditions returned true, then the micro:bit must be pointing West. Display `W` on the micro:bit.
+
+```blocks
+basic.forever(() => {
+    let degrees = input.compassHeading();
+    if (degrees < 45) {
+        basic.showString("N");
+    }
+    else if (degrees < 135) {
+        basic.showString("E");
+    }
+    else if (degrees < 225) {
+        basic.showString("S");
+    }
+    else {
+        basic.showString("W");
+    }
+});
+```
+
+### ~avatar avatar
+
+Excellent, you're ready to continue with the [challenges](/lessons/compass/challenges)!
+
+### ~
+

docs/projects/flashing-heart.md

@@ -0,0 +1,117 @@
+# flashing heart
+
+![](/static/mb/projects/a1-display.png)
+
+### ~avatar avatar
+
+```sim
+basic.forever(() => {
+basic.showLeds(`
+. # . # .
+# # # # #
+# # # # #
+. # # # .
+. . # . .`);
+basic.pause(500);
+basic.clearScreen();
+basic.pause(500);
+})
+```
+
+Use the LEDs to display a flashing heart, and then create
+an animation of a broken heart. :(
+
+## [START PROJECT](/#follow:/projects/flashing-heart)
+
+### ~
+
+## Step 1
+
+Use [show leds](/reference/basic/showLeds) and make your code look like this:
+
+```blocks
+basic.showLeds(`
+. # . # .
+# # # # #
+# # # # #
+. # # # .
+. . # . .`);
+```
+
+## Step 2
+
+Add a [pause](/reference/basic/pause) to wait and [clear screen](/reference/basic/clearScreen) to turn off the LEDs.
+
+```blocks
+basic.showLeds(`
+. # . # .
+# # # # #
+# # # # #
+. # # # .
+. . # . .`);
+basic.pause(500);
+basic.clearScreen();
+```
+
+## Step 3
+
+Put a [forever loop](/reference/basic/forever) around it.
+
+```blocks
+basic.forever(() => {
+basic.showLeds(`
+. # . # .
+# # # # #
+# # # # #
+. # # # .
+. . # . .`);
+basic.pause(500);
+basic.clearScreen();
+})
+```
+
+## Step 4
+
+Add a [pause](/reference/basic/pause) to wait after clearing the screen.
+
+```blocks
+basic.forever(() => {
+basic.showLeds(`
+. # . # .
+# # # # #
+# # # # #
+. # # # .
+. . # . .`);
+basic.pause(500);
+basic.clearScreen();
+basic.pause(500);
+})
+```
+
+## Step 5
+
+Add a second image of a broken heart. 
+
+
+```blocks
+basic.forever(() => {
+basic.showLeds(`
+. # . # .
+# # # # #
+# # # # #
+. # # # .
+. . # . .`);
+basic.pause(500);
+basic.clearScreen();
+basic.pause(500);
+basic.showLeds(`
+. # . # .
+# . # # #
+# . . . #
+. # # # .
+. . # . .`);
+basic.pause(500);
+basic.clearScreen();
+basic.pause(500);
+})
+```

docs/projects/hack-your-headphones-challenges.md

@@ -1,4 +1,4 @@
-# light beatbox activity
+# hack your headphones challenges
 
 Control sound with the light level. 
 
@@ -71,10 +71,3 @@ input.onButtonPressed(Button.A, () => {
 
 * click *compile* and run your code on the micro:bit.
 
-
-### ~avatar avatar
-
-Excellent, you're ready to continue by connecting your headphones with these [challenges](/lessons/hack-your-headphones/activity)!
-
-### ~
-

docs/projects/hack-your-headphones.md

@@ -1,4 +1,4 @@
-# hack your headphones activity 
+# hack your headphones 
 
 Hack your headphones
 
@@ -52,10 +52,10 @@ You hacked your headphones!
 
 ### Step 6
 
-Connect your micro:bit to your computer using your USB cable and program  [light beatbox](/lessons/light-beatbox/activity) music on it. Press the reset button to restart your music player!
+Connect your micro:bit to your computer using your USB cable and program  [light beatbox](/projects/hack-your-headphones-challenges) music on it. Press the reset button to restart your music player!
 
 ### ~avatar avatar
 
-Excellent, you're ready to continue with the [challenges](/lessons/light-beatbox/activity)!
+Excellent, you're ready to continue with the [challenges](/projects/hack-your-headphones-challenges)!
 
 ### ~

docs/projects/love-meter.md

@@ -0,0 +1,50 @@
+# love meter
+
+![](/static/mb/projects/a3-pins.png)
+
+Use pins P0, P1 and P2 to change the display by creating a circuit with your body.
+
+## Step 1
+
+Use [on pin pressed](/reference/input/on-pin-pressed) to show a random number
+when pin P0 is pressed (hold the GND pin with other hand):
+
+```blocks
+input.onPinPressed(TouchPin.P0, () => {
+    basic.showNumber(Math.random(11));
+});
+```
+## Step 2
+
+Show a string when pin P1 is pressed:
+
+```blocks
+input.onPinPressed(TouchPin.P0, () => {
+    basic.showNumber(Math.random(11));
+});
+input.onPinPressed(TouchPin.P1, () => {
+    basic.showString("LOVE?");
+});
+```
+
+## Step 3
+
+Show a heart when pin P2 is pressed:
+
+```blocks
+input.onPinPressed(TouchPin.P0, () => {
+    basic.showNumber(Math.random(11));
+});
+input.onPinPressed(TouchPin.P1, () => {
+    basic.showString("LOVE?");
+});
+input.onPinPressed(TouchPin.P2, () => {
+    basic.showLeds(`
+        . # # # .
+        # # # # #
+        # # # # #
+        . # # # .
+        . . # . .
+        `);
+});
+```

docs/projects/radio-challenges.md

@@ -2,7 +2,8 @@
 
 ### ~avatar avatar 
 
-Welcome! The activity will teach you how to use the acceleration of the 1st micro:bit and to visualize the acceleration on the 2nd micro:bit. Let's get started!
+Welcome! The activity will teach you how to use the acceleration of the 1st micro:bit and to visualize the acceleration on the 2nd micro:bit. 
+Let's get started!
 
 ### ~
 Let's measure `acceleration (mg)` and then `send number`. `Acceleration` is measured in **milli-gravities**, so a value of -1000 is equivalent to -1g or -9.81m/s^2. We will be able to get the acceleration value (g-force), in the specified "x" dimension. `Send number` will broadcast a number data packet to other micro:bits connected via radio.
@@ -52,7 +53,7 @@ Notice that moving the micro:bit the farthest direction in the x direction will
 NOTE: The colors of the charts reflect the color of the micro:bit simulator. In this instance, the micro:bits are blue and green. So the colors of the line graphs reflect the colors of the micro:bit
  
  ### ~
-After running this simulatation several seconds by moving the micro:bit side to side in the x direction, you are ready to graph or chart the accceleration of the micro:bit.  We want a printout of our acceleration on Excel. We will graph the fluctuating acceleration of the simulation experiment. 
+After running this simulation several seconds by moving the micro:bit side to side in the x direction, you are ready to graph or chart the accceleration of the micro:bit.  We want a printout of our acceleration on Excel. We will graph the fluctuating acceleration of the simulation experiment. 
 
 ![](/static/mb/acc2.png)
 
@@ -67,15 +68,9 @@ Use the Recommended Charts command on the Insert tab to quickly create a chart t
 
 * Click Insert > Recommended Charts.
 
-![](/static/mb/chart1.png)
+![](/static/mb/lessons/chart1.png)
 
-* On the Recommended Charts tab, scroll through the list of chart types that Excel recommends for your data.
-
-Click any chart type to see how your data will look in that format. 
-
-When you find the chart type that you want, click it, and then click OK. We want to select the chart called Line. A line chart is used to display trends over time. We will use the line chart because there are many data points over time. 
-
-Tip: If you don’t see a chart type that you want, click the All Charts tab to see all of the available chart types.
+* On the Recommended Charts tab, scroll through the list of chart types that Excel recommends for your data. Pick the **scatter plot**.
 
 ![](/static/mb/chart_title.png)
 
@@ -91,4 +86,3 @@ Have fun reviewing your simulation and analyze the acceleration by chart the Exc
 * The first person and second person take turns tilting the micro:bit in the "x" direction while the other player charts the data on the micro:bit!
 * Review and analyze the actual micro:bit device acceleration data on Excel
 * Display acceleration with y or z using plot bar graph by changing acceleration from "x" to "y" or "z" 
-

docs/projects/radio.md

@@ -0,0 +1,68 @@
+# radio 
+
+Measure the acceleration on the micro:bit in the "x" direction. 
+
+### ~avatar avatar
+
+Welcome! This activity will teach how to use the micro:bit to chart the acceleration in the "x" direction. Let's get started!
+
+
+### ~
+Let's measure `acceleration (mg)` in the "x" direction. Get the acceleration value (milli g-force), in one of three specified dimensions.
+
+
+```blocks
+input.acceleration(Dimension.X)
+```
+
+### ~
+Use the plot bar chart to visualize the acceleration on the LED screen of the micro:bit in the specified range. You implement plot Bar Graph to display a vertical bar graph based on the "value" and "high" value. Then you must insert acceleration in the X dimension to measure the acceleration. 
+
+```blocks
+basic.forever(() => {
+    led.plotBarGraph(input.acceleration(Dimension.X), 0)
+})
+
+```
+
+### ~
+Notice that moving the micro:bit in the simulator from left to right (x direction) changes the values beneath the micro:bit in a range from 1023 to -1023 as measured in milli-gravities. By hovering over the micro:bit from left to right, you can observe changing values beneath the micro:bit simulator. Also, the LEDs shown on the Bar Graph fluctates based on the movement of the micro:bit simulator in the x direction. The line underneath the micro:bit simulator reflect the acceleration in the x direction. 
+
+NOTE: The colors of the charts reflect the color of the micro:bit simulator. In this instance, the micro:bit is yellow. So the color of the data line reflects the color of the micro:bit
+
+![](/static/mb/data4.png)
+
+### ~
+ 
+Vigorously move the micro:bit in the micro:bit simulatator by moving the micro:bit image from side to side. Every time the micro:bit moves in the x direction in the simulator,  you are generating data points that can be reviewed in Excel. The more attempts to move the micro:bit from side to side, the more data being saved in Excel. After you have vigarously moved the micro:bit simulator from side to side for a sufficient amount of time, you are ready to graph or chart the accceleration of the micro:bit. We want a printout of our acceleration on Excel that can be graphed in Excel. 
+
+### ~
+
+We want to chart the data collected by using a tool in Excel. 
+
+The final part of this experiment is opening and reviewing the data in the Excel CSV file. Simply click on the line beneath the simulator. A CSV file will be generated to display the data points collected by moving the micro:bit in the X direction. Then click or tap on the data Excel file that was downloaded to your local ``Downloads`` Folder. 
+
+
+### ~
+
+
+First, click or tap on the first two columns (A, B) to  include the time of the data being collected; b) the results of acceleration data on the micro:bit  
+
+![](/static/mb/data7.png)
+
+Use the Recommended Charts command on the Insert tab to quickly create a chart that’s just right for your data.
+
+* Select the data that you want to include in your chart.
+
+* Click Insert > Recommended Charts.
+
+![](/static/mb/lessons/chart1.png)
+
+* On the Recommended Charts tab, scroll through the list of chart types that Excel recommends for your data. Pick the **scatter plot**.
+
+### ~avatar avatar
+
+Excellent, you're ready to continue with the [challenges](/projects/radio-challenges)
+
+### ~
+

docs/projects/rock-paper-scissors.md

@@ -0,0 +1,239 @@
+# rock paper scissors
+
+![](/static/mb/projects/a4-motion.png)
+
+### ~avatar avatar
+
+```sim
+input.onGesture(Gesture.Shake, () => {
+    let img = Math.random(3)
+    if (img == 0) {
+        basic.showLeds(`
+            # # # # #
+            # . . . #
+            # . . . #
+            # . . . #
+            # # # # #
+            `)
+
+    } else if (img == 1) {
+        basic.showLeds(`
+            . . . . .
+            . # # # .
+            . # # # .
+            . # # # .
+            . . . . .
+            `)
+    } else {
+        basic.showLeds(`
+            # # . . #
+            # # . # .
+            . . # . .
+            # # . # .
+            # # . . #
+            `)
+    }
+})
+```
+In this project, you will build a Rock Paper Scissors game with the BBC micro:bit.
+You can play the game with a friend who has it on a micro:bit.
+You can also play it with friends who are just using their hands.
+
+## [START PROJECT](/#follow:/projects/rock-paper-scissors)
+
+### ~
+
+
+## Materials needed
+
+* Your BBC micro:bit -- that's it!
+
+## Step 1: Getting started
+
+We want the micro:bit to choose rock, paper, or scissors when you shake it.
+Try creating an ``on shake`` block so when you shake the micro:bit, it will run part of a program.
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    
+})
+```
+
+Next, when you shake the micro:bit, it should pick a random number from `0` to `2`
+and store it in the variable `weapon`. (This variable is named `weapon` because 
+rock, paper, and scissors are the weapons you use to battle your friends!)
+
+Add a ``set`` block with a variable. Then add a ``pick random`` block,
+and store the random number in the variable,
+like this:
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    let weapon = Math.random(3)
+})
+
+```
+
+### ~hint
+No one can predict random numbers. That's what makes them great for Rock Paper Scissors!
+### ~
+
+Each possible number these blocks can make (`0`, `1`, or `2`) means a different picture.
+We will show the right picture for that number on the LED screen.
+
+
+## Step 2: Picking paper
+
+Put an ``if`` block after the ``let`` block that checks whether
+`weapon` is `0`. Make sure the ``if`` block has an ``else if`` part
+and an ``else`` part.
+
+Next, add a ``show leds`` block that shows a
+picture of a piece of paper:
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    let weapon = Math.random(3)
+    if (weapon == 0) {
+        basic.showLeds(`
+            # # # # #
+            # . . . #
+            # . . . #
+            # . . . #
+            # # # # #
+            `)
+    } else if (false) {
+
+    } else {
+
+    }
+})
+```
+
+## Step 3: A random rock
+
+Now we are going to add a new picture for the micro:bit to show
+when another random number comes up.
+
+Make the ``else if`` part check if the variable `weapon` is `1`.
+Then add a ``show leds`` block with a picture of a rock.
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    let weapon = Math.random(3)
+    if (weapon == 0) {
+        basic.showLeds(`
+            # # # # #
+            # . . . #
+            # . . . #
+            # . . . #
+            # # # # #
+            `)
+
+    } else if (weapon == 1) {
+        basic.showLeds(`
+            . . . . .
+            . # # # .
+            . # # # .
+            . # # # .
+            . . . . .
+            `)
+    } else {
+
+    }
+})
+```
+
+## Step 4: Suddenly scissors
+
+Add a ``show leds`` block with a picture of scissors to the ``else`` part:
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    let weapon = Math.random(3)
+    if (weapon == 0) {
+        basic.showLeds(`
+            # # # # #
+            # . . . #
+            # . . . #
+            # . . . #
+            # # # # #
+            `)
+
+    } else if (weapon == 1) {
+        basic.showLeds(`
+            . . . . .
+            . # # # .
+            . # # # .
+            . # # # .
+            . . . . .
+            `)
+    } else {
+        basic.showLeds(`
+            # # . . #
+            # # . # .
+            . . # . .
+            # # . # .
+            # # . . #
+            `)
+    }
+})
+
+```
+
+### ~hint
+
+You don't need to check if `weapon` is `2` because `2` is the only number left out of `0`, `1`, and `2`.
+That's why you can use an ``else`` instead of an ``else if``.
+
+### ~
+
+Your game is ready! Have fun!
+
+## Step 5: Are you the greatest?
+
+Here is a way you can make your Rock Paper Scissors game better.
+When button ``A`` is pressed, 
+the micro:bit will add `1` to your score.
+
+Open the ``Game`` drawer, and then add the block ``change score by 1`` to your program,
+like this:
+
+```blocks
+input.onButtonPressed(Button.A, () => {
+    game.addScore(1)
+})
+
+```
+
+## Step 6: Prove you're the greatest!
+
+After your micro:bit can add `1` to the score, show how many wins you have.
+
+```blocks
+input.onButtonPressed(Button.A, () => {
+    game.addScore(1)
+    basic.showString("WINS:")
+    basic.showNumber(game.score())
+})
+```
+## Step 7: Staying honest
+
+Success! Your micro:bit can track wins!
+But what about losses? 
+Use the ``Game`` drawer to subtract `1` from your score when you press button `B`. 
+
+Here are all the blocks you will need:
+
+```shuffle
+input.onButtonPressed(Button.B, () => {
+    game.addScore(-1)
+    basic.showString("LOSSES:")
+    basic.showNumber(game.score())
+})
+```
+
+## Step 8: Hacking Rock Paper Scissors
+
+How else can you make your game better?
+Ever hear of [Rock Paper Scissors Spock Lizard](http://www.samkass.com/theories/RPSSL.html)?

docs/projects/smiley-buttons.md

@@ -0,0 +1,69 @@
+# smiley buttons
+
+![](/static/mb/projects/a2-buttons.png)
+
+Use buttons to show a smiley or frowny face. 
+
+## Step 1
+
+Use [show leds](/reference/basic/showLeds) to make a smiley face:
+
+```blocks
+basic.showLeds(`
+. # . # .
+. # . # .
+. . . . .
+# . . . #
+. # # # .`);
+```
+
+## Step 2
+
+Add an input block for when [button A is pressed](/reference/input/button-is-pressed), and put a
+frowny face inside it:
+
+```blocks
+basic.showLeds(`
+. # . # .
+. # . # .
+. . . . .
+# . . . #
+. # # # .`);
+input.onButtonPressed(Button.A, () => { 
+    basic.showLeds(`
+    . # . # .
+    . # . # .
+    . . . . .
+    . # # # .
+    # . . . #`);
+});
+```
+
+## Step 3
+
+Now add blocks so that when [button B is pressed](/reference/input/button-is-pressed), a smiley appears:
+
+```blocks
+basic.showLeds(`
+. # . # .
+. # . # .
+. . . . .
+# . . . #
+. # # # .`);
+input.onButtonPressed(Button.A, () => { 
+    basic.showLeds(`
+    . # . # .
+    . # . # .
+    . . . . .
+    . # # # .
+    # . . . #`);
+});
+input.onButtonPressed(Button.B, () => { 
+    basic.showLeds(`
+    . # . # .
+    . # . # .
+    . . . . .
+    # . . . #
+    . # # # .`);
+});
+```

docs/projects/telegraph.md

@@ -70,6 +70,6 @@ Using the 4th crocodile clip, connect the unattached end of the crocodile clip o
 
 ### ~avatar avatar
 
-Excellent, you're ready to continue with the [challenges](/lessons/telegraph/challenges)!
+Excellent, you're ready to continue with the [challenges](/projects/telegraph-challenges)!
 
 ### ~

docs/projects/the-watch.md

@@ -1,8 +1,6 @@
-# The watch activity
+![](/static/mb/projects/a10-watch.png)
 
-Control images with variables. 
-
-# micro:bit watch
+# the watch
 
 ![](/static/mb/lessons/the-watch-0.png)
 
@@ -152,7 +150,7 @@ Your watch is ready!
 
 ### ~avatar avatar
 
-Excellent, you're ready to continue with the [challenges](/lessons/rock-paper-scissors/activity)!
+Excellent, you're ready to continue with the [challenges](/projects/rock-paper-scissors)!
 
 ### ~
 

docs/reference.md

@@ -1,10 +1,6 @@
 # Reference
 
 ```namespaces
-for (let i = 0;i<5;++i) {}
-if (true){}
-let x = 0;
-Math.random(5);
 basic.showNumber(0);
 input.onButtonPressed(Button.A, () => {
     
@@ -21,7 +17,7 @@ images.createImage(`
 . . . . .
 `);
 pins.digitalReadPin(DigitalPin.P0);
-serial.writeValue(x, 0);
+serial.writeNumber(0);
 control.inBackground(() => {
     
 });

docs/reference/String.md

@@ -0,0 +1,5 @@
+# String
+
+```cards
+String.fromCharCode(0);
+```

docs/reference/basic/clear-screen.md

@@ -21,10 +21,6 @@ basic.showLeds(`
 basic.clearScreen()
 ```
 
-### Lessons
-
-[blink](/lessons/blink), [flashing heart](/lessons/flashing-heart), [screen wipe](/lessons/screen-wipe)
-
 ### See also
 
 [set brightness](/reference/led/set-brightness), [unplot](/reference/led/unplot), [plot](/reference/led/plot), [Image](/reference/images/image), [clear](/reference/basic/clear-screen)

docs/reference/basic/forever.md

@@ -63,10 +63,6 @@ input.onButtonPressed(Button.A, () => {
 })
 ```
 
-### Lessons
-
-[blink](/lessons/blink), [snowflake-fall](/lessons/snowflake-fall), [flashing-heart](/lessons/flashing-heart)
-
 ### See also
 
 [while](/reference/loops/while), [on button pressed](/reference/input/on-button-pressed), [in background](/reference/control/in-background)

docs/reference/basic/pause.md

@@ -24,10 +24,6 @@ for (let i = 0; i < 5; i++) {
 }
 ```
 
-### Lessons
-
-[blink](/lessons/blink), [lucky 7](/lessons/lucky-7), [smiley](/lessons/smiley), [flashing heart](/lessons/flashing-heart)
-
 ### See also
 
 [while](/reference/loops/while), [running time](/reference/input/running-time), [for](/reference/loops/for)

docs/reference/basic/show-animation.md

@@ -62,8 +62,3 @@ basic.showAnimation(`
 Use [forever](/reference/basic/forever) to show an animation over and over.
 
 ### ~
-
-### Lessons
-
-[smiley](/lessons/smiley), [snowflake fall](/lessons/snowflake-fall), [rotation animation](/lessons/rotation-animation)
-

docs/reference/basic/show-leds.md

@@ -1,6 +1,6 @@
 # Show LEDs
 
-Display an image on the BBC micro:bit's [LED screen](/device/screen).
+Shows a picture on the [LED screen](/device/screen).
 
 ```sig
 basic.showLeds(`
@@ -15,13 +15,13 @@ basic.showLeds(`
 
 ### Parameters
 
-* `leds` is a [String](/reference/types/string) that shows which LEDs are on and off.
-* `ms` is an optional [Number](/reference/types/number) that shows how many milliseconds to wait after showing a picture.
-If you are programming with blocks, `ms` starts out as 400 milliseconds.
+* `leds` is a [string](/reference/types/string) that controls which LEDs are on and off.
+* `interval` is an optional [number](/reference/types/number) that means how many milliseconds to wait after showing a picture.
+If you are programming with blocks, `interval` is set at 400 milliseconds.
 
 ### Example
 
-Open the `basic` card in the Block Editor and select the `show leds` blocks.
+This program shows a picture with the ``show leds`` function.
 
 ```blocks
 basic.showLeds(`
@@ -34,11 +34,12 @@ basic.showLeds(`
 )
 ```
 
-If you are programming in JavaScript, `#` means an LED that is turned on and `.` means an LED that is turned off.
+### ~hint
 
-### Lessons
+If you are programming in JavaScript, `#` means an LED that is turned
+on and `.` means an LED that is turned off.
 
-[smiley](/lessons/smiley), [flashing heart](/lessons/flashing-heart), [magic logo](/lessons/magic-logo)
+### ~
 
 ### See also
 

docs/reference/basic/show-number.md

@@ -42,10 +42,6 @@ for (let i = 0; i < 6; i++) {
 * Use [show string](/reference/basic/show-string) to show a [String](/reference/types/string) with letters on the screen.
 * Use [show animation](/reference/basic/show-animation) to show a group of pictures on the screen, one after another.
 
-### Lessons
-
-* [lucky 7](/lessons/lucky-7)
-
 ### See also
 
 [show string](/reference/basic/show-string), [show animation](/reference/basic/show-animation), [Number](/reference/types/number), [math library](/reference/math)

docs/reference/basic/show-string.md

@@ -31,10 +31,6 @@ basic.showString(s)
 * Use [show number](/reference/basic/show-number) to show a number on the [LED screen](/device/screen).
 * Use [show animation](/reference/basic/show-animation) to show a group of pictures on the screen, one after another.
 
-### Lessons
-
-[answering machine](/lessons/answering-machine), [rock paper scissors](/lessons/rock-paper-scissors), [love meter](/lessons/love-meter)
-
 ### See also
 
 [String](/reference/types/string), [show number](/reference/basic/show-number), [show animation](/reference/basic/show-animation)

docs/reference/game/change-score-by.md

@@ -24,8 +24,3 @@ export function addScore(points: number)
 ```
 export function score() : number
 ```
-
-### Lessons
-
-[game of chance](/lessons/game-of-chance), [game counter](/lessons/game-counter)
-

docs/reference/game/change.md

@@ -19,8 +19,3 @@ Sprite will change the y position by this number
 ```
 export function changeYBy(_this: micro_bitSprites.LedSprite, y: number)
 ```
-
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/game-library.md

@@ -1,18 +1,10 @@
 # Game Library
 
-The game library #docs
-
 The game library supports simple single-player time-based games. The player has a **sprite**, number of **lives** and a **score**. The game has a sprite, number of **levels** and a **countdown clock**.  The general goal of a game will be to move the sprite and achieve a top score before time runs out or the number of lives goes to zero.
 
-## Block Editor
-
-![](/static/mb/game-library/pic0.png)
-
-## KindScript
-
 The code below shows a simple game where the user gets to press the button ``A`` as much times as possible in 10 seconds.
 
-```
+```blocks
 input.onButtonPressed(Button.A, () => {
     game.addScore(1)
 })
@@ -154,8 +146,3 @@ You can also end the game by calling the `game -> game over` function:
 ```
 game.gameOver()
 ```
-
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/game-over.md

@@ -18,7 +18,3 @@ You can end the game by calling the `game -> game over` function:
 game.gameOver()
 ```
 
-### Lessons
-
-[game of chance](/lessons/game-of-chance)
-

docs/reference/game/move.md

@@ -1,22 +1,7 @@
 # Move
 
-The game library 
-
-### Move
-
-Sprite move by a certain number
-
-## Block Editor
-
-![](/static/mb/game-library/move-0.png)
-
-## KindScript
+Sprite move by a certain number of LEDs
 
 ```
 export function move(_this: micro_bitSprites.LedSprite, leds: number)
 ```
-
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/position.md

@@ -1,19 +1,5 @@
 # Position
 
-The game library 
-
-### Create sprite
-
-Reports the x or y position of a sprite on the LED screen
-
-## Block Editor
-
-Reports the x position of a sprite on the LED screen
-
-![](/static/mb/game-library/position-0.png)
-
-## KindScript
-
 Reports the x position of a sprite on the LED screen
 
 ```
@@ -25,8 +11,3 @@ Reports the y position of a sprite on the LED screen
 ```
 export function y(_this: micro_bitSprites.LedSprite) : number
 ```
-
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/reports.md

@@ -1,31 +1,7 @@
 # Reports
 
-The game library
-
-### Reports
-
 Reports the x or y position,  the current direction of a sprite, or the brightness of a sprite on the LED screen
 
-## Block Editor
-
-Reports the x position of a sprite on the LED screen
-
-![](/static/mb/game-library/position-0.png)
-
-Reports the y position of a sprite on the LED screen
-
-![](/static/mb/game-library/reports-0.jpg)
-
-Reports the brightness of a sprite on the LED screen
-
-![](/static/mb/game-library/reports-1.jpg)
-
-Reports the direction of a sprite on the LED screen
-
-![](/static/mb/game-library/reports-2.jpg)
-
-## KindScript
-
 Reports the x position of a sprite on the LED screen
 
 ```
@@ -49,8 +25,3 @@ Reports the current direction of a sprite on the LED screen
 ```
 export function direction(_this: micro_bitSprites.LedSprite) : number
 ```
-
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/score.md

@@ -1,20 +1,10 @@
 # Score
 
-The game library #docs
-
 The game library supports simple single-player games. The player has a **score**.
 
-## Block Editor
-
-The code below shows a simple game where the user gets to press the button ``A`` and adds 1 point to score that will be displayed on the BBC micro:bit screen
-
-![](/static/mb/game-library/add-point-to-score-0.png)
-
-## KindScript
-
 The code below shows a simple game where the user gets to press the button ``A`` as much times as possible in 10 seconds.
 
-```
+```blocks
 input.onButtonPressed(Button.A, () => {
     game.addScore(1)
 })
@@ -53,7 +43,3 @@ If your game has a time limit, you can start a countdown in which case `game->cu
 export function startCountdown(ms: number)
 ```
 
-### Lessons
-
-[game of chance](/lessons/game-of-chance), [game counter](/lessons/game-counter)
-

docs/reference/game/start-countdown.md

@@ -1,15 +1,5 @@
 # Start Countdown
 
-The game library #docs
-
-The game library supports simple single-player time-based games. The general goal of a game will be to achieve a top score before time runs out of time.
-
-## Block Editor
-
-![](/static/mb/game-library/start-countdown-0.png)
-
-## KindScript
-
 The code below shows a simple game where the user gets to press the button ``A`` as much times as possible in 10 seconds.
 
 ```
@@ -50,8 +40,3 @@ If your game has a time limit, you can start a countdown in which case `game->cu
 ```
 export function startCountdown(ms: number)
 ```
-
-### Lessons
-
-[bop it](/lessons/bop-it) | [game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/touching.md

@@ -1,24 +1,8 @@
 # Touching
 
-The game library 
-
-### Touching
-
-Reports true if sprite is touching specified sprite
-
-## Block Editor
-
-![](/static/mb/game-library/touching-0.png)
-
-## KindScript
-
 Reports true if sprite is touching specified sprite
 
 ```
 export function isTouching(_this: micro_bitSprites.LedSprite, other: micro_bitSprites.LedSprite) : boolean
 ```
 
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/turn.md

@@ -1,17 +1,5 @@
 # Turn
 
-The game library 
-
-Rotates a sprite to the right by a certain number of degrees
-
-## Block Editor
-
-Rotates a sprite to the right by a certain number of degrees
-
-![](/static/mb/game-library/turn-0.png)
-
-## KindScript
-
 Rotates a sprite to the right by a certain number of degrees
 
 ```
@@ -24,7 +12,3 @@ Rotates a sprite to the left by a certain number of degrees
 export function turnLeft(_this: micro_bitSprites.LedSprite, degrees: number)
 ```
 
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/images/create-image.md

@@ -29,10 +29,6 @@ input.onGesture(Gesture.Shake, () => {
 })
 ```
 
-### Lessons
-
-[rock paper scissors](/lessons/rock-paper-scissors), [digital pet](/lessons/digital-pet), [offset-image](/lessons/offset-image)
-
 ### See also
 
 [show animation](/reference/basic/show-animation), [image](/reference/images/image), [show image](/reference/image/show-image), [scroll image](/reference/image/scroll-image)

docs/reference/images/image.md

@@ -46,10 +46,6 @@ You should see code similar to this:
 * [show image](/reference/images/show-image): show an image on the screen
 * [scroll image](/reference/images/scroll-image): scroll an image on the screen
 
-### Lessons
-
-* [smiley](/lessons/smiley)
-
 ### See also
 
 [Show LEDs](/reference/basic/show-leds), [create image](/reference/images/create-image), [show image](/reference/images/show-image), [LED screen](/device/screen)

docs/reference/images/plot-frame.md

@@ -31,10 +31,6 @@ let img = images.createImage(`
 img.plotFrame(1)
 ```
 
-### Lessons
-
-[smiley](/lessons/smiley), [flashing heart](/lessons/flashing-heart), [magic logo](/lessons/magic-logo)
-
 ### See also
 
 [create image](/reference/images/create-image), [show animation](/reference/basic/show-animation), [image](/reference/images/image), [show image](/reference/images/show-image), [scroll image](/reference/images/scroll-image)

docs/reference/images/plot-image.md

@@ -31,10 +31,6 @@ let img = images.createImage(`
 img.plotImage(0)
 ```
 
-### Lessons
-
-[smiley](/lessons/smiley), [flashing heart](/lessons/flashing-heart), [magic logo](/lessons/magic-logo)
-
 ### See also
 
 [create image](/reference/images/create-image), [show animation](/reference/basic/show-animation), [image](/reference/images/image), [show image](/reference/images/show-image), [scroll image](/reference/images/scroll-image)

docs/reference/images/show-frame.md

@@ -31,10 +31,6 @@ let img = images.createImage(`
 img.showFrame(1)
 ```
 
-### Lessons
-
-[smiley](/lessons/smiley), [flashing heart](/lessons/flashing-heart), [magic logo](/lessons/magic-logo)
-
 ### See also
 
 [create image](/reference/images/create-image), [show animation](/reference/basic/show-animation), [image](/reference/images/image), [show image](/reference/images/show-image), [scroll image](/reference/images/scroll-image)

docs/reference/images/show-image.md

@@ -45,10 +45,6 @@ for (let i = 0; i < 5; i++) {
 }
 ```
 
-### Lessons
-
-[rock paper scissors](/lessons/rock-paper-scissors), [digital pet](/lessons/digital-pet), [offset-image](/lessons/offset-image)
-
 ### See also
 
 [show animation](/reference/basic/show-animation), [image](/reference/images/image), [create image](/reference/images/create-image), [scroll image](/reference/images/scroll-image)

docs/reference/input/acceleration.md

@@ -2,46 +2,39 @@
 
 Get the acceleration value (milli g-force), in one of three specified dimensions.
 
+Find the acceleration of the micro:bit (how fast it is speeding up or slowing down).
+
 ```sig
 input.acceleration(Dimension.X);
 ```
 
+## ~hint
+
+You measure acceleration with the **milli-g**, which is 1/1000 of a **g**.
+A **g** is as much acceleration as you get from Earth's gravity.
+
+## ~
+
+
+
 ### Parameters
 
-* dimension : [String](/reference/types/string) - one of three values specifying the axis of acceleration: ``x`` (left/right); ``y`` (forward/backwards); ``z`` (up/down)
+* which direction you are checking for acceleration, either `Dimension.X` (left and right), `Dimension.Y` (forward and backward), or `Dimension.Z` (up and down)
 
 ### Returns
 
-* [Number](/reference/types/number) - acceleration, in milli-gravities. When the micro:bit is laying flat with the screen up, x=0, y=0 and z=-1023.
+* a [number](/reference/types/number) that means the amount of acceleration. When the micro:bit is lying flat on a surface with the screen pointing up, `x` is `0`, `y` is `0`, and `z` is `-1023`.
 
 ### Example: bar chart
 
-Use the ``plot bar chart`` to visual the acceleration on the LED screen.
+This example shows the acceleration of the micro:bit with a bar graph.
 
 ```blocks
 basic.forever(() => {
-    led.plotBarGraph(input.acceleration("x"), 1023)
+    led.plotBarGraph(input.acceleration(Dimension.X), 1023)
 })
 ```
 
-### Example: micro:bit leveller
-
-The following example uses the `acceleration` and the `plot` function to help you move the micro:bit until it's level (the centre LED is *on* when the device is level). When running this code in a web browser, move your mouse to simulate the accelerometer.
-
-```blocks
-basic.forever(() => {
-    let ax = input.acceleration(Dimension.X)
-    let x = pins.map(-1023, 1023, 0, 4, ax)
-    let ay = input.acceleration("y")
-    let y = pins.map(-1023, 1023, 0, 4, ay)
-    basic.clearScreen()
-    led.plot(x, y)
-})
-```
-
-### Lessons
-
-[zoomer](/lessons/zoomer)
 
 ### See also
 

docs/reference/input/button-is-pressed.md

@@ -33,10 +33,6 @@ basic.forever(() => {
 })
 ```
 
-### Lessons
-
-[zoomer](/lessons/zoomer)
-
 ### See also
 
 [on button pressed](/reference/input/on-button-pressed), [if](/reference/logic/if), [forever](/reference/basic/forever)

docs/reference/input/compass-heading.md

@@ -1,6 +1,10 @@
 # Compass Heading
 
-Get the compass heading of the micro:bit in degrees. Your micro:bit has a built-in **magnetometer** so it can your direction with respect to the North Magnetic Pole.
+Find which direction on a compass the micro:bit is facing.
+
+The micro:bit measures the **compass heading** from `0` to `360`
+degrees with its **magnetometer** chip. Different numbers mean north,
+east, south, and west.
 
 ```sig
 input.compassHeading();
@@ -8,15 +12,12 @@ input.compassHeading();
 
 ### Returns
 
-* [Number](/reference/types/number) - the heading in degrees (0 to 360 degrees). If the compass is calibrating, it returns ``-1003``.
-
-## Simulator
-
-Calibration does not work on the simulator.
+* a [number](/reference/types/number) from `0` to `360` degrees, which means the compass heading. If the compass isn't ready, it returns `-1003`.
 
 ### Example
 
-The following code gets the compass heading and stores it in the `degrees` variable:
+This program finds the compass heading and stores it in the
+`degrees` variable.
 
 ```blocks
 let degrees = input.compassHeading()
@@ -24,13 +25,16 @@ let degrees = input.compassHeading()
 
 ### ~hint 
 
-When running code with this function in a web browser, click and drag the on-screen compass needle to change heading.
+When you run a program that uses this function in a browser, click and drag
+the compass needle on the screen to change the compass heading.
 
 ### ~
 
 ### Example: compass
 
-The following example gets the `compass heading` and then displays a letter depending on the value of `degrees`: N for north, E for East, S for South, and W for West.
+This program finds the compass heading and then shows a letter
+that means whether the micro:bit is facing north (N), south (S),
+east (E), or west (W).
 
 ```blocks
 basic.forever(() => {
@@ -47,17 +51,14 @@ basic.forever(() => {
 
 ### Calibration
 
-On the first use of the compass, the **calibration** procedure will automatically start. The user must draw a circle with the device until it is fully calibrated.
+Every time you start to use the compass (for example, if you have just
+turned the micro:bit on), the micro:bit will start to **calibrate**
+(adjust itself).  It will ask you to draw a circle by tilting the
+micro:bit.
 
-An enclosure made from metal, or using in proximity of metal objects, might affect the accuracy of the reading and calibration.
-
-During calibration, ``compass heading`` returns ``-1003``.
-
-### Lessons
-
-[compass](/lessons/compass)
+If you are calibrating or using the compass near metal, it might
+confuse the micro:bit.
 
 ### See also
 
 [acceleration](/reference/input/acceleration)
-

docs/reference/input/light-level.md

@@ -43,8 +43,6 @@ basic.forever(() => {
 })
 ```
 
-### Lessons
-
 ### See also
 
 [acceleration](/reference/input/acceleration), [compass-heading](/reference/input/compass-heading)

docs/reference/input/magnetic-force.md

@@ -1,27 +1,35 @@
 # Magnetic Force
 
-Get the magnetic force (micro Teslas), in one of three specified dimensions.
+Find the amount of magnetic force (the strength of a magnet) in the direction you say.
 
 ```sig
 input.magneticForce(Dimension.X);
 ```
 
+## ~hint
+
+The micro:bit measures magnetic force with **microteslas**.
+
+## ~
+
+
 ### Parameters
 
-* dimension : [String](/reference/types/string) - one of three values specifying the axis of the force: ``x`` (left/right); ``y`` (forward/backwards); ``z`` (up/down); ``strength`` (the length of the vector)
+* a [string](/reference/types/string) that says which direction the micro:bit should measure magnetic force in: either `x` (the left-right direction), `y` (the forward/backward direction), or `z` (the up/down direction)
 
 ### Returns
 
-* [Number](/reference/types/number) - magnetic force, in micro-Teslas.
+* a [number](/reference/types/number) of microteslas that means the strength of the magnet
 
 ### Example: metal detector
 
-The following example uses the `magnetic force` to control the brightness of the screen. When the magnetic force increases, the center LED will appear brighter.
+This program makes the center LED of the micro:bit get brighter when
+the magnetic force is stronger, and dimmer when it is weaker.
 
 ```blocks
 led.plot(2, 2)
 basic.forever(() => {
-    let f = input.magneticForce(Dimension.X)
+    let f = input.magneticForce("x")
     led.setBrightness(f / 2000)
 })
 ```
@@ -29,4 +37,3 @@ basic.forever(() => {
 ### See also
 
 [compass heading](/reference/input/compass-heading)
-

docs/reference/input/on-button-pressed.md

@@ -41,10 +41,6 @@ Otherwise, sometimes they would show a `0`.
 
 ### ~
 
-### Lessons
-
-[smiley](/lessons/smiley), [answering machine](/lessons/answering-machine), [screen wipe](/lessons/screen-wipe), [rotation animation](/lessons/rotation-animation)
-
 ### See also
 
 [button is pressed](/reference/input/button-is-pressed), [forever](/reference/basic/forever), [random](/reference/math/math)

docs/reference/input/on-gesture.md

@@ -1,19 +1,17 @@
 # On Gesture
 
-Register an [event handler](/reference/event-handler) that will execute whenever the user executes a gesture withthe BBC micro:bit.
+Start an [event handler](/reference/event-handler) (part of the
+program that will run when something happens) This handler works when
+you do a **gesture** (like shake, tilt, or drop the micro:bit).
 
 ```sig
 input.onGesture(Gesture.Shake,() => {
 })
 ```
 
-## Gestures
+## Example: random number
 
-
-
-### Example: random number
-
-The following example displays a number from 0-9 on the screen when you shake the BBC micro:bit.
+This program shows a number from `0` to `9` when you shake the micro:bit.
 
 ```blocks
 input.onGesture(Gesture.Shake,() => {
@@ -22,24 +20,3 @@ input.onGesture(Gesture.Shake,() => {
 })
 ```
 
-### Example: rock, paper, scissors
-
-The following example shows one of three images (rock, paper, or scissors) when you shake the BBC micro:bit.
-
-```blocks
-input.onGesture(Gesture.Shake,() => {
-    let img = images.createImage(`
-. . . . . # # # # # . . . . #
-. # # # . # . . . # # # . # .
-. # # # . # . . . # . # # . .
-. # # # . # . . . # # # . # .
-. . . . . # # # # # . . . . #
-`)
-    img.showFrame(Math.random(3))
-})
-```
-
-### Lessons
-
-[bounce image](/lessons/bounce-image), [rock paper scissors](/lessons/rock-paper-scissors)
-

docs/reference/input/on-pin-pressed.md

@@ -1,17 +1,31 @@
 # On Pin Pressed
 
-Register an [event handler](/reference/event-handler) that will execute whenever the user holds the `GND` pin with one hand, and presses pin `0`, `1`, or `2` with the other hand, thus completing a circuit; when you run a script with this function in a web browser, click pins 0 , 1, or 2 on the simulator.
+Start an [event handler](/reference/event-handler) (part of the program 
+that will run when something happens, like when a button is pressed). 
+This handler works when you press pin `0`, `1`, or `2` together with `GND`.
+When you are using this function in a web browser, click the pins on the screen instead of the ones
+on the BBC micro:bit.
 
-*Note* that this function works best when the BBC micro:bit is powered by AAA battery.
+If you hold the `GND` pin with one hand and touch pin `0`, `1`, or `2` with the other,
+a very small (safe) amount of electricity will flow through your body and back into
+the micro:bit. This is called **completing a circuit**. It's like you're a big wire!
 
 ```sig
 input.onPinPressed(TouchPin.P0, () => {
 })
 ```
 
+## ~hint
+
+This function works best when the BBC micro:bit is using batteries for power,
+instead of the USB cable.
+
+## ~
+
 ### Example: pin pressed counter
 
-This example counts how many times the P0 pin is pressed. Each time the pin is pressed, the global count variable is increased by 1 and displayed on the screen.
+This program counts how many times you press the `P0` pin. 
+Every time you press the pin, the program shows the number of times on the screen.
 
 ```blocks
 let count = 0
@@ -22,10 +36,6 @@ input.onPinPressed(TouchPin.P0, () => {
 })
 ```
 
-### Lessons
-
-[love meter](/lessons/love-meter)
-
 ### See also
 
 [BBC micro:bit pins](/device/pins), [pin is pressed](/reference/input/pin-is-pressed), [analog read pin](/reference/pins/analog-read-pin), [analog write pin](/reference/pins/analog-write-pin), [digital read pin](/reference/pins/digital-read-pin), [digital write pin](/reference/pins/digital-write-pin)

docs/reference/input/pin-is-pressed.md

@@ -1,24 +1,33 @@
 # Pin Is Pressed
 
-Gets the pin state (pressed or not pressed), by detecting when the user holds the `GND` pin with one hand, and presses pin `0`, `1`, or `2` with the other hand, thus completing a circuit.
+Find whether the pin you say is pressed or not pressed.
 
-*Note* that this function works best when the BBC micro:bit is powered by AAA battery.
+If you hold the `GND` pin with one hand and touch pin `0`, `1`, or `2` with the other,
+a very small (safe) amount of electricity will flow through your body and back into
+the micro:bit. This is called **completing a circuit**. It's like you're a big wire!
 
 ```sig
 input.pinIsPressed(TouchPin.P0);
 ```
 
+## ~hint
+
+This function works best when the BBC micro:bit is using batteries for power,
+instead of the USB cable.
+
+## ~
+
 ### Parameters
 
-* name - [String](/reference/types/string); the pin name ("P0", "P1", or "P2")
+* a [string](/reference/types/string) that holds the pin name (**P0**, **P1**, or **P2**)
 
 ### returns
 
-* [Boolean](/reference/types/boolean) - `true` if pressed, `false` if not pressed
+* a [boolean](/reference/types/boolean) that means whether the pin you say is pressed (`true` or `false`)
 
 ### Example
 
-This example displays 1 if P0 is pressed, and 0 if P0 is not pressed:
+This program shows `1` if `P0` is pressed, and `0` if `P0` is not pressed:
 
 ```blocks
 basic.forever(() => {

docs/reference/input/rotation.md

@@ -1,45 +1,58 @@
 # Rotation
 
-Get a rotation angle in degrees inferred from the accelerometer readings.
+Find how much the micro:bit is tilted in different directions.
 
 ```sig
 input.rotation(Rotation.Roll);
 ```
 
+## ~hint
+
+The BBC micro:bit has a part called the **accelerometer** that can
+check how the micro:bit is moving.
+
+## ~
+
 ### Parameters
 
-* kind: [String](/reference/types/string) - one of values specifying the kind of rotation: ``pitch`` (up/down around the ``x`` axis); ``roll`` (left/right around the ``y`` axis)
+* which direction you are checking: `Rotation.Pitch` (up and down) or `Rotation.Roll` (left and right)
 
 ### Returns
 
-* [Number](/reference/types/number) - angle, in degrees.
+* a [number](/reference/types/number) that means how much the microbit is tilted in the direction you say, from `0` to `360` degrees
 
-### Example: micro:bit leveller
+### Example: micro:bit leveler
 
-The following example uses the `rotation` and the `plot leds` function to help you move the BBC micro:bit until it's level: when it is level, a smiley shows up on the screen. When running this code in a web browser, move your mouse to simulate the rotation.
+This program helps you move the BBC micro:bit until it is level.  When
+it is level, the micro:bit shows a smiley.
 
-```sig
+If you are running this program in a browser, you can tilt the
+micro:bit with your mouse.
+
+
+```blocks
+let pitch = 0;
 basic.forever(() => {
-    let pitch = input.rotation(Rotation.Pitch)
-    let roll = input.rotation(Rotation.Roll)
+    pitch = input.rotation(Rotation.Pitch);
+    let roll = input.rotation(Rotation.Roll);
     if (Math.abs(pitch) < 10 && Math.abs(roll) < 10) {
-        basic.plotLeds(`
-. . . . .
+        basic.showLeds(`
             . # . # .
             . . . . .
+            . . . . .
             # . . . #
             . # # # .
-`)
+            `);
     } else {
-        basic.plotLeds(`
+        basic.showLeds(`
             # . . . #
             . # . # .
             . . # . .
             . # . # .
             # . . . #
-`)
+            `);
         }
-})
+	});
 ```
 
 ### See also

docs/reference/input/running-time.md

@@ -24,9 +24,6 @@ input.onButtonPressed(Button.B, () => {
 })
 ```
 
-### Lessons
-
-[speed button](/lessons/speed-button)
 
 ### See also
 

docs/reference/input/temperature.md

@@ -1,6 +1,7 @@
 # Temperature
 
-Get the ambient temperature (degree Celsius °C). The temperature is inferred from the the surface temperature of the various chips on the micro:bit.
+Find the temperature where you are. The temperature is measured in Celsius (metric).
+The micro:bit can find the temperature nearby by checking how hot its computer chips are.
 
 ```sig
 input.temperature();
@@ -8,26 +9,48 @@ input.temperature();
 
 ### Returns
 
-* [Number](/reference/types/number) - temperature in degree Celsius °C.
+* a [Number](/reference/types/number) that means the Celsius temperature.
 
 ### How does it work?
 
-The BBC micro:bit does not have a dedicated temperature sensor. Instead, the temperature provided is actually the temperature of the silicon die on the main CPU. As the processor generally runs cold though (it is a high efficiency ARM core), the temperature is a good approximation of the ambient temperature... you might warm up if you give the processor a lot of work to do though, and don't [sleep](/reference/basic/pause)!
-
-The temperature sensor has a high precision, but isn't trimmed for accuracy. In other words, it can sense changes in temperature very well, but there may be (and probably is) base line offset. i.e. it might return 20 degrees when it's actually 17, but it would return 21 when it is 18 etc.
+The BBC micro:bit checks how hot its CPU (main computer chip) is.
+Because the micro:bit does not usually get very hot, the temperature of the CPU
+is usually close to the temperature of wherever you are.
+The micro:bit might warm up a little if you make it work hard, though!
 
 ### Example: micro:bit thermometer
 
-The following example uses the `temperature` and the `show number` to display the room temperature.
+The following example uses `temperature` and `show number` to show the temperature of the room.
 
-```sig
+```blocks
 basic.forever(() => {
     let temp = input.temperature()
     basic.showNumber(temp)
 })
 ```
+### Example: Fahrenheit thermometer
 
-### Lessons
+This program measures the temperature using Fahrenheit degrees.
+Fahrenheit is a way of measuring temperature that is commonly used in the United States.
+To make a Celsius temperature into a Fahrenheit one, multiply the Celsius temperature by
+1.8 and add 32.
+
+```blocks
+basic.forever(() => {
+    let c = input.temperature()
+    let f = (c * 1.8) + 32
+    basic.showNumber(f)
+})
+```
+
+### ~hint
+
+Try comparing the temperature your micro:bit shows to a real thermometer in the same place.
+You might be able to figure out how much to subtract from the number the micro:bit
+shows to get the real temperature. Then you can change your program so the micro:bit is a 
+better thermometer.
+
+### ~
 
 ### See also
 

docs/reference/led/brightness.md

@@ -1,6 +1,6 @@
 # Brightness
 
-Find how bright the [LED screen](/device/screen) is.
+Find how bright the [LED screen](/device/screen) is _when it is turned on_.
 
 ```sig
 led.brightness();
@@ -8,11 +8,11 @@ led.brightness();
 
 ### Returns
 
-* a [Number](/reference/types/number) that means how bright the screen is, from `0` (darkest) to `255` (brightest). For example, the number `127` means the screen is halfway bright.
+* a [number](/reference/types/number) that means how bright the screen is when it is turned on, from `0` (darkest) to `255` (brightest). For example, the number `127` means the screen is halfway bright when it is turned on.
 
 ### Example: highest brightness
 
-This program makes the screen completely bright if it is not that way already:
+This program makes the screen completely bright when it is turned on (if it is not that way already):
 
 ```blocks
 if (led.brightness() < 255) {
@@ -20,6 +20,20 @@ if (led.brightness() < 255) {
 }
 ```
 
+
+### Example: change brightness
+
+This program makes the screen brightness 100% (255).  Then it turns on
+the center LED (`2, 2`), waits for one second and then sets the screen
+brightness to 50% (128):
+
+```blocks
+led.setBrightness(255)
+led.plot(2, 2)
+basic.pause(1000)
+led.setBrightness(led.brightness() / 2)
+```
+
 ### See also
 
 [set brightness](/reference/led/set-brightness), [fade in](/reference/led/fade-in), [fade out](/reference/led/fade-out)

docs/reference/led/fade-in.md

@@ -24,10 +24,6 @@ for (let i = 0; i < 5; i++) {
 }
 ```
 
-### Lessons
-
-[glowing sword](/lessons/glowing-sword)
-
 ### See also
 
 [brightness](/reference/led/brightness), [fade out](/reference/led/fade-out), [set brightness](/reference/led/set-brightness)

docs/reference/led/fade-out.md

@@ -20,10 +20,6 @@ basic.showString("A", 1000)
 led.fadeOut(1000)
 ```
 
-### Lessons
-
-[glowing sword](/lessons/glowing-sword)
-
 ### See also
 
 [brightness](/reference/led/brightness), [fade in](/reference/led/fade-in), [set brightness](/reference/led/set-brightness)

docs/reference/led/plot-all.md

@@ -6,10 +6,6 @@ Turn on all the 25 LEDs on the [LED screen](/device/screen).
 led.plotAll()
 ```
 
-### Lessons
-
-[night light](/lessons/night-light)
-
 ### See also
 
 [LED screen](/device/screen), [clear screen](/reference/basic/clear-screen)

docs/reference/led/plot-leds.md

@@ -28,10 +28,6 @@ basic.plotLeds(`
 `)
 ```
 
-### Lessons
-
-[smiley](/lessons/smiley), [flashing heart](/lessons/flashing-heart), [magic logo](/lessons/magic-logo)
-
 ### See also
 
 [show animation](/reference/basic/show-animation), [image](/reference/images/image), [show image](/reference/images/show-image), [scroll image](/reference/images/scroll-image)

docs/reference/led/plot.md

@@ -1,35 +1,47 @@
 # Plot
 
-Turn on a LED light on the [LED screen](/device/screen). Specify which LED using x, y coordinates. Use [unplot](/reference/led/unplot) to turn a LED off.
+Turn on the LED light you say on the [LED screen](/device/screen).
 
 ```sig
 led.plot(0,0);
 ```
 
+## ~hint
+
+Use [unplot](/reference/led/unplot) to turn **off** an LED.
+
+## ~
+
 ### Parameters
 
-* x - [Number](/reference/types/number); the *x coordinate* or horizontal position (0, 1, 2, 3, 4)
-* y - [Number](/reference/types/number); the *y coordinate* or vertical position (0, 1, 2, 3, 4)
+* **x** is a [number](/reference/types/number) that means the horizontal spot on the LED screen (from left to right: 0, 1, 2, 3, or 4)
+* **y** is a [number](/reference/types/number) that means the vertical spot on the LED screen (from top to bottom: 0, 1, 2, 3, or 4)
 
-If a parameter is [out of bounds](/reference/out-of-bounds) (a value other than 0-4), then this function will do nothing.
+If a parameter is [out of bounds](/reference/out-of-bounds) (a value
+other than 0 to 4), then this function will do nothing.
 
-### x, y coordinates?
+### ~hint
 
-The LED screen is made up of 25 LEDs arranged in a 5x5 grid. To figure out the ``x``, ``y`` coordinates, see [LED screen](/device/screen).
+The LED screen is a solid square of LEDs with five LEDs on each side.
+To learn more about how you number the LEDs with ``x`` and ``y``
+coordinates, see [LED screen](/device/screen).
 
-This code turns on the centre LED:
+### ~
+
+### Example: One LED
+
+This program turns on the bottom right LED.
 
 ```blocks
-led.plot(2, 2)
+led.plot(4, 4)
 ```
 
-### Get the LED on/off state
 
-Use the [point](/reference/led/point) function to find out if a LED is on or off.
+### Example: Square
 
-### Example: a square
-
-The following example uses a [for loop](/reference/loops/for) and the `plot` function to turn on the LED lights along the edge of the screen, making a square:
+This program uses a [for loop](/reference/loops/for)
+and the `plot` function
+to make a square around the edges of the LED screen.
 
 ```blocks
 for (let i = 0; i < 5; i++) {
@@ -41,11 +53,13 @@ for (let i = 0; i < 5; i++) {
 }
 ```
 
-### Lessons
+### ~hint
 
-[blink](/lessons/blink), [beautiful  image](/lessons/beautiful-image), [strobe light](/lessons/strobe-light)
+Use the [point](/reference/led/point) function to find out if an LED is
+on or off.
+
+### ~
 
 ### See also
 
 [unplot](/reference/led/unplot), [point](/reference/led/point), [LED screen](/device/screen)
-

docs/reference/led/point.md

@@ -1,6 +1,7 @@
 # Point
 
-Get the on/off state of a LED on the [LED screen](/device/screen). Specify the LED using x, y coordinates.
+Find whether the LED you say on the 
+[LED screen](/device/screen) is on or off.
 
 ```sig
 led.point(0,0);
@@ -8,30 +9,36 @@ led.point(0,0);
 
 ### Parameters
 
-* x  - [Number](/reference/types/number); the *x coordinate* or horizontal position (0, 1, 2, 3, 4)
-* y - [Number](/reference/types/number); the *y coordinate* or vertical position (0, 1, 2, 3, 4)
+* **x** is a [number](/reference/types/number) that means the horizontal spot on the LED screen (from left to right: 0, 1, 2, 3, or 4)
+* **y** is a [number](/reference/types/number) that means the vertical spot on the LED screen (from top to bottom: 0, 1, 2, 3, or 4)
 
-If a parameter is [out of bounds](/reference/out-of-bounds) (a value other than 0-4), then this function will return `false`.
+If a parameter is [out of bounds](/reference/out-of-bounds) (a value
+other than 0 to 4), this function will return `false`.
 
 ### Returns
 
-* [Boolean](/reference/types/boolean) - `true` if the LED is *on* and `false` if the LED is *off*
+* a [boolean](/reference/types/boolean). If it is `true`, that means the LED is on. If it is `false`, that means the LED is off.
 
-### x, y coordinates?
+### ~hint
 
-The LED screen is made up of 25 LEDs arranged in a 5x5 grid. To figure out the ``x``, ``y`` coordinates, see [LED screen](/device/screen).
+The LED screen is a solid square of LEDs with five LEDs on each side.
+To learn more about how you number the LEDs with ``x`` and ``y``
+coordinates, see [LED screen](/device/screen).
 
-### Example: toggle off
+### ~
 
-If `point(1, 1)` returns `true`, then the following code turns off the LED:
+### Example: Toggle off
+
+This program turns the center LED (2, 2) off if it is already on.  (If
+it is already off, this program leaves it off.)
 
 ```blocks
-if (led.point(1, 1)) {
-    led.unplot(1, 1)
+if (led.point(2, 2)) {
+    led.unplot(2, 2)
 }
 ```
 
 ### See also
 
-[unplot](/reference/led/unplot), [plot](/reference/led/plot), [LED screen](/device/screen), [create image](/reference/images/create-image)
+[unplot](/reference/led/unplot), [plot](/reference/led/plot), [LED screen](/device/screen)
 

docs/reference/led/set-brightness.md

@@ -1,6 +1,7 @@
 # Set Brightness
 
-Sets the brightness of the [LED screen](/device/screen).
+Make the [LED screen](/device/screen) as bright as you say when it is
+turned on.
 
 ```sig
 led.setBrightness(121)
@@ -8,23 +9,21 @@ led.setBrightness(121)
 
 ### Parameters
 
-* value : [Number](/reference/types/number) - the brightness of the LED screen expressed as a number between 0 and 255
+* a [number](/reference/types/number) that means how bright the screen is when it is turned on, from `0` (darkest) to `255` (brightest). For example, the number `127` means the screen is halfway bright when it is turned on.
 
 ### Example: change brightness
 
-The following example sets the screen brightness to 100% (255), turns on LED `2, 2`, waits for a second and then sets the screen brightness to 50% (127):
+This program makes the screen brightness 100% (255).  Then it turns on
+the center LED (`2, 2`), waits for one second, and then sets the screen
+brightness to 50% (128):
 
 ```blocks
 led.setBrightness(255)
 led.plot(2, 2)
 basic.pause(1000)
-led.setBrightness(127)
+led.setBrightness(led.brightness() / 2)
 ```
 
-### Lessons
-
-[night light](/lessons/night-light)
-
 ### See also
 
 [brightness](/reference/led/brightness), [fade in](/reference/led/fade-in), [fade out](/reference/led/fade-out), [LED screen](/device/screen)

docs/reference/led/unplot.md

@@ -1,35 +1,36 @@
 # Unplot
 
-Turn off a LED light on the [LED screen](/device/screen). Specify which LED using x, y coordinates. Use [plot](/reference/led/plot) to turn a LED on.
+Turn off the LED light you say on the [LED screen](/device/screen).
 
 ```sig
 led.unplot(0,0)
 ```
 
+## ~hint
+
+Use [plot](/reference/led/plot) to turn **on** an LED.
+
+## ~
+
 ### Parameters
 
-* x - [Number](/reference/types/number); the *x coordinate* or horizontal position (0, 1, 2, 3, 4)
-* y - [Number](/reference/types/number); the *y coordinate* or vertical position (0, 1, 2, 3, 4)
+* **x** is a [number](/reference/types/number) that means the horizontal spot on the LED screen (from left to right: 0, 1, 2, 3, or 4)
+* **y** is a [number](/reference/types/number) that means the vertical spot on the LED screen (from top to bottom: 0, 1, 2, 3, or 4)
 
-If a parameter is [out of bounds](/reference/out-of-bounds) (a value other than 0-4), this function will do nothing.
+If a parameter is [out of bounds](/reference/out-of-bounds) (a value
+other than 0 to 4), then this function will do nothing.
 
-### x, y coordinates?
+### ~hint
 
-The LED screen is made up of 25 LEDs arranged in a 5x5 grid. To figure out the ``x``, ``y`` coordinates, see [LED screen](/device/screen).
+The LED screen is a solid square of LEDs with five LEDs on each side.
+To learn more about how you number the LEDs with ``x`` and ``y``
+coordinates, see [LED screen](/device/screen).
 
-This code turns off centre LED:
+### ~
 
-```blocks
-led.unplot(2, 2)
-```
+### Example: Center off 
 
-### Get the LED on/off state
-
-Use the [point](/reference/led/point) function to find out if a LED is on or off.
-
-### Example: toggle off
-
-This code creates and shows an image on the micro:bit screen, and then clears the centre LED using `unplot`:
+This program shows a picture on the LED screen, and then turns off the center LED with `unplot`.
 
 ```blocks
 basic.showLeds(`
@@ -43,11 +44,14 @@ basic.pause(500)
 led.unplot(2, 2)
 ```
 
-### Lessons
+### ~hint
+
+Use the [point](/reference/led/point) function to find out if an LED is
+on or off.
+
+### ~
 
-[strobe light](/lessons/strobe-light)
 
 ### See also
 
-[plot](/reference/led/plot), [point](/reference/led/point), [LED screen](/device/screen), [create image](/reference/images/create-image)
-
+[plot](/reference/led/plot), [point](/reference/led/point), [LED screen](/device/screen)

docs/reference/logic/if.md

@@ -22,10 +22,6 @@ if(input.lightLevel()<100){
 
 If the [light level](/input/light-level) is `< 100`, this code sets the brightness to `255`:
 
-### Lessons
-
-[love meter](/lessons/love-meter), [zoomer](/lessons/zoomer)
-
 ### See also
 
 [while loop](/reference/loops/while), [for](/reference/loops/for), [boolean](/reference/types/boolean)

docs/reference/loops.md

@@ -2,7 +2,6 @@
 
 ```cards
 for(let i = 0;i<5;i++) {}
-for(let i = 1;i<5;i++) {}
 while(true) {}
 basic.forever(() => {})
 ```

docs/reference/loops/for.md

@@ -14,10 +14,6 @@ basic.showNumber(i)
 }
 ```
 
-### Lessons
-
-[looper](/lessons/looper)
-
 ### See also
 
 [repeat](/reference/loops/repeat), [while](/reference/loops/while), [if](/reference/logic/if), [show number](/reference/basic/show-number)

docs/reference/loops/repeat.md

@@ -6,10 +6,6 @@ Run part of the program the number of times you say.
 
 ![](/static/mb/blocks/contents-0.png)
 
-### Lessons
-
-[looper](/lessons/looper)
-
 ### See also
 
 [for](/reference/loops/for), [while](/reference/loops/while), [if](/reference/logic/if), [show number](/reference/basic/show-number)

docs/reference/loops/while.md

@@ -26,10 +26,6 @@ while(index >= 0) {
 }
 ```
 
-### Lessons
-
-[rotation animation](/lessons/rotation-animation)
-
 ### See also
 
 [on button pressed](/reference/input/on-button-pressed), [for](/reference/loops/for), [if](/reference/logic/if), [forever](/reference/basic/forever)

docs/reference/math/math.md

@@ -42,10 +42,6 @@ returns a random [Number](/reference/types/number) between 0 and the parameter *
 
 ![](/static/mb/blocks/math-3.png)
 
-### Lessons
-
-[love meter](/lessons/love-meter)
-
 ### See also
 
 [Block Editor documentation](/blocks/contents), [Number](/reference/types/number)

docs/reference/music/change-tempo.md

@@ -1,10 +1,11 @@
 # Change Tempo By
 
-Change the tempo by the specified amount
+Makes the [tempo](/reference/music/tempo) (speed of a piece of music)
+faster or slower by the amount you say.
 
 ## Simulator
 
-Simulation of this function is available in many, but not all browsers.
+This function only works on the micro:bit and in some browsers.
 
 ```sig
 music.changeTempoBy(20)
@@ -12,7 +13,21 @@ music.changeTempoBy(20)
 
 ### Parameters
 
-* `bpm` : [Number](/reference/types/number) - change the tempo by beats per minute
+* a [number](/reference/types/number) that says how much to change the bpm (beats per minute, or number of beats in a minute of the music that the micro:bit is playing).
+
+### Examples
+
+This program makes the music faster by 12 bpm.
+
+```blocks
+music.changeTempoBy(12)
+```
+
+This program makes the music _slower_ by 12 bpm.
+
+```blocks
+music.changeTempoBy(-12)
+```
 
 ### See also
 

docs/reference/music/rest.md

@@ -1,10 +1,10 @@
 # Rest
 
-Rests (plays nothing) for a specified time through pin PO.
+Rest (play no sound) through pin `PO` for the amount of time you say.
 
 ## Simulator
 
-Simulation of this function is available in many, but not all browsers.
+This function only works on the micro:bit and in some browsers.
 
 ```sig
 music.rest(400)
@@ -12,7 +12,7 @@ music.rest(400)
 
 ### Parameters
 
-* `ms`: [Number](/reference/types/number) - the duration of the rest (milliseconds)
+* a [number](/reference/types/number) saying how many milliseconds the micro:bit should rest. One second is 1000 milliseconds.
 
 ## Example
 

docs/reference/music/ring-tone.md

@@ -1,10 +1,11 @@
 # Ring Tone
 
-Play a continuous tone through pin P0.
+Play a musical tone through pin `P0` with the pitch as high or low as you say.
+The tone will keep playing until you tell it not to.
 
 ## Simulator
 
-Simulation of this function is available in many, but not all browsers.
+This function only works on the micro:bit and in some browsers.
 
 ```sig
 music.ringTone(440)
@@ -12,11 +13,18 @@ music.ringTone(440)
 
 ### Parameters
 
-* `frequency` : [Number](/reference/types/number) - Plays a tone in (Hz)
+* a [number](/reference/types/number) that says the tone's
+**frequency** (how high-pitched or low-pitched the tone is).  This
+number is in **Hz** (**Hertz**), which is a measurement of frequency
+or pitch.
 
 ### Example
 
-Play a sound based on the tile of the device
+This program checks the **accelerometer** for the micro:bit's
+**acceleration** (how much the micro:bit is speeding up or slowing
+down). Then it uses that acceleration to make a tone.  If the micro:bit
+speeds up, the tone's pitch gets higher, and if it slows down, the
+tone's pitch gets lower.  It's fun -- try it!
 
 ```blocks
 basic.forever(() => {
@@ -26,5 +34,6 @@ basic.forever(() => {
 
 ### See also
 
-[rest](/reference/music/rest), [play tone](/reference/music/play-tone) , [tempo](/reference/music/tempo), [set tempo](/reference/music/set-tempo), [change tempo by](/reference/music/change-tempo-by)
-
+[rest](/reference/music/rest), [play tone](/reference/music/play-tone),
+[tempo](/reference/music/tempo), [set tempo](/reference/music/set-tempo),
+[change tempo by](/reference/music/change-tempo-by)

docs/reference/music/set-tempo.md

@@ -1,14 +1,17 @@
 # Set Tempo 
 
-Sets the tempo to the specified amount
+Makes the tempo (speed of a piece of music) as fast or slow as you say.
 
 ```sig
 music.setTempo(60)
 ```
+## Simulator
+
+This function only works on the micro:bit and in some browsers.
 
 ### Parameters
 
-* Returns : [Number](/reference/types/number) - sets the tempo in beats per minute
+* a [number](/reference/types/number) that means the bpm you want (beats per minute, or number of beats in a minute of the music that the micro:bit is playing).
 
 ### See also
 

docs/reference/pins.md

@@ -8,6 +8,7 @@ pins.digitalWritePin(DigitalPin.P0, 0);
 pins.analogReadPin(AnalogPin.P0);
 pins.analogWritePin(AnalogPin.P0, 1023);
 pins.analogSetPeriod(AnalogPin.P0, 20000);
+pins.map(0, 0, 1023, 0, 4);
 pins.onPulsed(DigitalPin.P0, PulseValue.High, () => {
     
 });
@@ -16,7 +17,6 @@ pins.servoWritePin(AnalogPin.P0, 180);
 pins.servoSetPulse(AnalogPin.P0, 1500);
 pins.i2cReadNumber(0, NumberFormat.Int8LE);
 pins.i2cWriteNumber(0, 0, NumberFormat.Int8LE);
-pins.map(0, 0, 1023, 0, 4);
 pins.analogPitch(0, 0);
 pins.analogSetPitchPin(AnalogPin.P0);
 ```