pxt-microbit 6.1.4 → 6.1.6

package/docs/projects/rock-paper-scissors.md

@@ -4,172 +4,227 @@
 
 ![Cartoon of the Rock Paper Scissors game](/static/mb/projects/a4-motion.png)
 
-Use the accelerometer and the screen to build a **Rock Paper Scissors** game that you can play with your friends!
+Turn your micro:bit into a **Rock Paper Scissors** game that you can play with your friends!
 
-## {Step 1 @fullscreen}
+## {Step 1}
 
-Let's use a ``||input:on shake||`` block to run code when you shake the @boardname@.
+First we need to make a variable to keep track of whether we have a Rock, Paper or Scissors in our hand. A variable is a container for storing values. Click on the ``||variables:Variables||`` category in the Toolbox. Click on the **Make a Variable** button. Give your new variable the name "hand" and click Ok.
+
+![A animation that shows how to create a variable](/static/mb/projects/rock-paper-scissors/newvar.gif)
+
+## {Step 2}
+
+Click on the ``||variables:Variables||`` category in the Toolbox again. You'll notice that there are some new blocks that have appeared. Drag a ``||variables:set hand||`` block into the ``||input:on shake||`` block. We'll start our Rock Paper Scissors game when we shake 👋 our micro:bit.
 
 ```blocks
+let hand = 0;
 input.onGesture(Gesture.Shake, function() {
-
+    hand = 0
 })
 ```
 
-## {Step 2 @fullscreen}
+## {Step 3}
 
-Add a ``hand`` variable and place the ``||variables:set hand to||`` block in the shake event.
+Click on the ``||math:Math||`` category in the Toolbox. Drag a ``||math:pick random||`` block and drop it into the ``||variables:set hand||`` block replacing the number 0. Now when we shake our micro:bit, the variable hand will contain a random number between 1 and 3.
 
-![A animation that shows how to create a variable](/static/mb/projects/rock-paper-scissors/newvar.gif)
+```blocks
+let hand = 0;
+input.onGesture(Gesture.Shake, function() {
+    hand = randint(1, 3)
+})
+```
 
-## {Step 3 @fullscreen}
+## {Step 4}
 
-Add a ``||math:pick random||`` block to pick a random number from `1` to `3` and store it in the variable named ``hand``.
+Click on the ``||logic:Logic||`` category in the Toolbox. Drag the ``||logic:if true then else||`` block out to the workspace and drop it into the ``||input:on shake||`` block under the ``||variables:set hand||`` block.
 
 ```blocks
 let hand = 0;
 input.onGesture(Gesture.Shake, function() {
     hand = randint(1, 3)
+    if (true) {
+    	
+    } else {
+    	
+    }
 })
 ```
 
-In a later step, each of the possible numbers (`1`, `2`, or `3`) is matched to its own picture. The picture is shown on the LEDs when its matching number is picked.
+## {Step 5}
 
-## {Step 4 @fullscreen}
+From the ``||logic:Logic||`` category, drag a ``||logic:0 = 0||`` comparison block and drop it into the ``||logic:if true then else||`` block replacing **true**.
 
-Place an ``||logic:if||`` block under the ``||math:pick random||`` and check whether ``hand`` is equal to ``1``. Add a ``||basic:show leds||`` block that shows a picture of a piece of paper. The number `1` will mean paper.
+```blocks
+let hand = 0;
+input.onGesture(Gesture.Shake, function() {
+    hand = randint(1, 3)
+    if (0 == 0) {
+    	
+    } else {
+    	
+    }
+})
+```
 
-![How to drag an if statement](/static/mb/projects/rock-paper-scissors/if.gif)
+## {Step 6}
+
+Click on the ``||variables:Variables||`` category in the Toolbox. Drag a ``||variables:hand||`` block out and drop it into the ``||logic:0 = 0||`` comparison block replacing the first **0**.  Click on the second 0 in the comparison block and change to **1**.
 
 ```blocks
 let hand = 0;
 input.onGesture(Gesture.Shake, function() {
     hand = randint(1, 3)
     if (hand == 1) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
+    	
+    } else {
+    	
     }
 })
 ```
 
-## {Step 5 @fullscreen}
+## {Step 7}
 
-Click on the **SHAKE** button in the simulator. If you try enough times, you should see a picture of paper on the screen.
+Click on the ``||basic:Basic||`` category in the Toolbox. Drag a ``||basic:show icon||`` block out and drop it under ``||logic:if hand = 1 then||``. In the ``||basic:show icon||`` block, click on the Heart icon and instead select the small square icon to represent a 💎 Rock.
 
-![Shaking a @boardname@ simulator](/static/mb/projects/rock-paper-scissors/rpsshake.gif)
-
-## {Step 6 @fullscreen}
+```blocks
+let hand = 0;
+input.onGesture(Gesture.Shake, function() {
+    hand = randint(1, 3)
+    if (hand == 1) {
+    	basic.showIcon(IconNames.SmallSquare)
+    } else {
+    	
+    }
+})
+```
 
-Click the **(+)** button to add an ``||logic:else||`` section.
+## {Step 8}
 
-![Adding an else clause](/static/mb/projects/rock-paper-scissors/ifelse.gif)
+At the bottom of the ``||logic:if then else||`` block, click on the plus **'+'** sign. This will expand the code to include an ``||logic:else if||`` clause.
 
 ```blocks
 let hand = 0;
 input.onGesture(Gesture.Shake, function() {
     hand = randint(1, 3)
     if (hand == 1) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
+    	basic.showIcon(IconNames.SmallSquare)
+    } else if (false) {
+    	
     } else {
+    	
+    }
+})
+```
+
+## {Step 9}
+
+From the ``||logic:Logic||`` category, drag a ``||logic:0 = 0||`` comparison block and drop it into the open space next to the ``||logic:else if||`` clause.
 
+```blocks
+let hand = 0;
+input.onGesture(Gesture.Shake, function() {
+    hand = randint(1, 3)
+    if (hand == 1) {
+    	basic.showIcon(IconNames.SmallSquare)
+    } else if (0 == 0) {
+    	
+    } else {
+    	
     }
 })
 ```
 
-## {Step 7 @fullscreen}
+## {Step 10}
 
-Add a ``||basic:show leds||`` block inside the ``||logic:else||``. Make a picture of a scissors in the LEDs.
+From the ``||variables:Variables||`` category, drag a ``||variables:hand||`` block and drop it into the ``||logic:0 = 0||`` comparison block replacing the first **0**.  Click on the second 0 in the comparison block and change to **2**.
 
 ```blocks
 let hand = 0;
 input.onGesture(Gesture.Shake, function() {
     hand = randint(1, 3)
     if (hand == 1) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
+    	basic.showIcon(IconNames.SmallSquare)
+    } else if (hand == 2) {
+    	
     } else {
-        basic.showLeds(`
-            # # . . #
-            # # . # .
-            . . # . .
-            # # . # .
-            # # . . #
-            `)
+    	
     }
 })
 ```
 
-## {Step 8 @fullscreen}
+## {Step 11}
 
-Click the ``+`` button again to add an ``||logic:else if||`` section. Now, add a conditional block for ``||logic:hand = 2||`` to the condition in ``||logic:else if||``. Since ``hand`` can only be `1`, `2`, or `3`, your code is covering all possible cases!
+From the ``||basic:Basic||`` category, drag a ``||basic:show icon||`` block out and drop it under ``||logic:else if hand = 2 then||``. In the ``||basic:show icon||`` block, click on the Heart icon and instead select the large square icon to represent 📃 Paper.
 
-![Adding an else if clause](/static/mb/projects/rock-paper-scissors/ifelseif.gif)
+```blocks
+let hand = 0;
+input.onGesture(Gesture.Shake, function() {
+    hand = randint(1, 3)
+    if (hand == 1) {
+    	basic.showIcon(IconNames.SmallSquare)
+    } else if (hand == 2) {
+    	basic.showIcon(IconNames.Square)
+    } else {
+    	
+    }
+})
+```
 
-## {Step 9 @fullscreen}
+## {Step 12}
 
-Get one more ``||basic:show leds||`` block and put it in the ``||logic:else if||``. Make a picture of a rock in the LEDs.
+Now let's deal with the last condition - if our hand variable isn't holding a 1 (Rock) or a 2 (Paper), then it must be 3 (✀ Scissors)! From the ``||basic:Basic||`` category, drag another ``||basic:show icon||`` block out and drop it into the last opening under the ``||logic:else||``.  In the ``||basic:show icon||`` block, click on the Heart icon and select the Scissors icon.
 
 ```blocks
 let hand = 0;
 input.onGesture(Gesture.Shake, function() {
     hand = randint(1, 3)
     if (hand == 1) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
+    	basic.showIcon(IconNames.SmallSquare)
     } else if (hand == 2) {
-        basic.showLeds(`
-            . . . . .
-            . # # # .
-            . # # # .
-            . # # # .
-            . . . . .
-            `)
+    	basic.showIcon(IconNames.Square)
     } else {
-        basic.showLeds(`
-            # # . . #
-            # # . # .
-            . . # . .
-            # # . # .
-            # # . . #
-            `)
+    	basic.showIcon(IconNames.Scissors)
     }
 })
 ```
 
-## {Step 10 @fullscreen}
+## {Step 13}
 
-Click on the **SHAKE** button in the simulator and check to see that each image is showing up.
+Let's test your code! Press the white **SHAKE** button on the micro:bit on-screen simulator, or move your cursor quickly back and forth over the simulator. Do you see the icons for rock, paper and scissors randomly appear?  ⭐ Great job! ⭐
 
 ![Shaking a @boardname@ simulator](/static/mb/projects/rock-paper-scissors/rpssim3.gif)
 
-## {Step 11 @fullscreen}
+## {Step 14}
 
-If you have a @boardname@, click on ``|Download|`` and follow the instructions to get the code
-onto your @boardname@. Your game is ready! Gather your friends and play Rock Paper Scissors!
+If you have a @boardname@ device, connect it to your computer and click the ``|Download|`` button. Follow the instructions to transfer your code onto the @boardname@. Once your code has been downloaded, attach your micro:bit to a battery pack and challenge another micro:bit or a human to a game of Rock, Paper, Scissors!
 
 ![A @boardname@ in a hand](/static/mb/projects/rock-paper-scissors/hand.jpg)
 
+## {Step 15}
+
+Go further - Try adding 🎵 Music 🎵 blocks to your Rock Paper Scissors game for different sound effects. Note that some Music blocks may require a micro:bit v2 device to play.
+
+```blocks
+let hand = 0
+input.onGesture(Gesture.Shake, function () {
+    hand = randint(1, 3)
+    if (hand == 1) {
+        basic.showIcon(IconNames.SmallSquare)
+        music.play(music.builtinPlayableSoundEffect(soundExpression.giggle), music.PlaybackMode.UntilDone)
+    } else if (hand == 2) {
+        basic.showIcon(IconNames.Square)
+        music.play(music.tonePlayable(262, music.beat(BeatFraction.Whole)), music.PlaybackMode.UntilDone)
+    } else {
+        basic.showIcon(IconNames.Scissors)
+        music.play(music.createSoundExpression(WaveShape.Square, 1600, 1, 255, 0, 300, SoundExpressionEffect.None, InterpolationCurve.Curve), music.PlaybackMode.UntilDone)
+    }
+})
+```
+
+```blockconfig.global
+randint(1, 3)
+```
+
 ```template
 input.onGesture(Gesture.Shake, function() {})
 ```

package/docs/projects/smiley-buttons.md

@@ -1,83 +1,61 @@
 # Smiley Buttons
 
-## {Introduction @unplugged}
+## Code a micro:bit emoji! @unplugged
 
-Code the buttons on the @boardname@ to show that it's happy or sad.
-(Want to learn how the buttons works? [Watch this video](https://youtu.be/t_Qujjd_38o)).
+Program the buttons on the @boardname@ to show a happy 😀 or sad face 🙁
 
 ![Pressing the A and B buttons](/static/mb/projects/smiley-buttons/sim.gif)
 
 ## {Step 1}
 
-Use the ``||input:on button pressed||`` block to run code when button **A** is pressed.
+Let's show a happy face when we press button **A**.  
+Click on the ``||basic:Basic||`` category in the Toolbox. Drag a ``||basic:show icon||`` block into the ``||input:on button A pressed||`` block.  
+In the ``||basic:show icon||`` block, click on the Heart icon to open the menu. Select a Happy Face icon.
 
 ```blocks
 input.onButtonPressed(Button.A, function() { 
+    basic.showIcon(IconNames.Happy)
 })
 ```
 
 ## {Step 2}
 
-Place a ``||basic:show leds||`` block inside ``||input:on button pressed||`` to display a smiley on the screen. Press the **A** button in the simulator to see the smiley.
-
-```blocks
-input.onButtonPressed(Button.A, function() { 
-    basic.showLeds(`
-        # # . # #
-        # # . # #
-        . . . . .
-        # . . . #
-        . # # # .`
-        )
-})
-```
+In the @boardname@ simulator on the screen, press the **A** button. Do you see a happy face? ⭐ Great job! ⭐
 
 ## {Step 3}
 
-Add ``||input:on button pressed||`` and ``||basic:show leds||`` blocks to display a frowny when button **B** is pressed.
+Now let's show a sad face when we press button **B**.  
+Click on the ``||input:Input||`` category in the Toolbox. 
+Drag another ``||input:on button A pressed||`` block onto the coding workspace (you can place this anywhere). 
+Click on the **A** button drop-down menu, and select **B**.
 
 ```blocks
-input.onButtonPressed(Button.B, function() { 
-    basic.showLeds(`
-        # # . # #
-        # # . # #
-        . . . . .
-        . # # # .
-        # . . . #`
-        );
-});
+input.onButtonPressed(Button.B, function() {})
 ```
 
 ## {Step 4}
 
-Add a secret mode that happens when **A** and **B** are pressed together. For this case, add multiple ``||basic:show leds||`` blocks to create an animation.
+From the ``||basic:Basic||`` category, drag another ``||basic:show icon||`` block into the ``||input:on button B pressed||`` block. 
+In this ``||basic:show icon||`` block, click on the Heart icon to open the menu. 
+Select a Sad Face icon.
 
 ```blocks
-input.onButtonPressed(Button.AB, function() {
-    basic.showLeds(`
-        . . . . .
-        # . # . .
-        . . . . .
-        # . . . #
-        . # # # .
-        `)
-    basic.showLeds(`
-        . . . . .
-        . . # . #
-        . . . . .
-        # . . . #
-        . # # # .
-        `)    
+input.onButtonPressed(Button.B, function() {
+    basic.showIcon(IconNames.Sad)
 })
 ```
-
 ## {Step 5}
 
-If you have a @boardname@, connect it to USB and click ``|Download|`` to transfer your code. Press button **A** on your @boardname@. Try button **B** and then **A** and **B** together.
+In the @boardname@ simulator on the screen, press the **B** button. Do you see a sad face? ⭐ Great job! ⭐
 
 ## {Step 6}
 
-Nice! Now go and show it off to your friends!
+If you have a @boardname@ device, connect it to your computer and click the ``|Download|`` button. Follow the instructions to transfer your code onto the @boardname@. Try pressing the **A** and **B** buttons on the micro:bit to see your happy 😀 and sad 🙁 emojis!
+
+## {Step 7}
+
+Go further - try adding a secret emoji that appears when **A** and **B** buttons are pressed together! 
+Learn more about how the @boardname@ buttons work by watching [this video](https://youtu.be/t_Qujjd_38o).
 
 ```template
 input.onButtonPressed(Button.A, function() {})

package/docs/projects/spy/dice.md

@@ -2,18 +2,15 @@
 
 ### @explicitHints true
 
-## Introduction @unplugged
+## {Introduction @unplugged}
 
-Let's turn the @boardname@ into a dice!
-(Want to learn how the accelerometer works? [Watch this video](https://youtu.be/byngcwjO51U)).
-
-We need 3 pieces of code: one to detect a throw (shake), another to pick a random number, and then one to show the number.
+Let's create some digital 🎲 dice 🎲 with our micro:bit!
 
 ![A @boardname@ dice](/static/mb/projects/dice.png)
 
-## Step 1
+## {Step 1}
 
-Add an event to run code when a ``||input:shake gesture||`` is detected.
+We'll "roll" our dice when we shake the micro:bit. Add an ``||input:on gesture shake||`` function. Type the code below, or drag a code snippet from the ``||input:Input||`` Toolbox category.
 
 ```spy
 input.onGesture(Gesture.Shake, function() {
@@ -21,9 +18,9 @@ input.onGesture(Gesture.Shake, function() {
 })
 ```
 
-## Step 2
+## {Step 2}
 
-Put code in the event to ``||basic:show a number||`` when ``||input:on shake||`` happens.
+Write some code to show a number in the ``||input:on shake||`` function, using the basic ``||basic:show number||`` function.
 
 ```spy
 input.onGesture(Gesture.Shake, function() {
@@ -31,9 +28,9 @@ input.onGesture(Gesture.Shake, function() {
 })
 ```
 
-## Step 3
+## {Step 3}
 
-Pick a ``||math:pick a random||`` number and ``||basic:show||`` it on the screen.
+Instead of showing 0, use the ``||math:randint||`` function to show a random number between a minimum and maximum value.
 
 ```spy
 input.onGesture(Gesture.Shake, function() {
@@ -41,9 +38,9 @@ input.onGesture(Gesture.Shake, function() {
 })
 ```
 
-## Step 4
+## {Step 4}
 
-A typical dice shows values from `1` to `6`. Change the minimum and maximum values in ``||math:pick random||`` to ``1`` and ``6``!
+A typical dice shows values from 1 to 6 dots. So, in the ``||math:randint||`` function, change the minimum value to **1** and the maximum value to **6**.
 
 ```spy
 input.onGesture(Gesture.Shake, function() {
@@ -51,10 +48,13 @@ input.onGesture(Gesture.Shake, function() {
 })
 ```
 
-## Step 5
+## {Step 5}
+
+Press the white **SHAKE** button on the micro:bit simulator. Do you see random numbers between 1 and 6 appear? ⭐ Great job! ⭐
 
-Use the simulator to try out your code. Does it show the number you expected?
+## {Step 6}
 
-## Step 6
+If you have a @boardname@ device, connect it to your computer and click the ``|Download|`` button. Follow the instructions to transfer your code onto the @boardname@. Once your code has been downloaded, attach your micro:bit to a battery pack and use it as digital 🎲 dice for your next boardgame!
 
-If you have a @boardname@ connected, click ``|Download|`` and transfer your code to the @boardname@!
+## {Step 7}
+Go further - Try adding some Music blocks to make a sound when you shake your dice, or use the micro:bit LED lights to show number values. Want to learn how the micro:bit motion detector or accelerometer works? [Watch this video](https://youtu.be/byngcwjO51U).

package/docs/projects/spy/flashing-heart.md

@@ -2,24 +2,23 @@
 
 ### @explicitHints true
 
-## Introduction @unplugged
+## Code a Flashing Heart @unplugged
 
-Learn how to use the LEDs and make a flashing heart! 
-(Want to learn how lights work? [Watch this video](https://youtu.be/qqBmvHD5bCw)).
+Code the lights on the micro:bit into a flashing heart animation! 💖
 
 ![Heart shape in the LEDs](/static/mb/projects/flashing-heart/sim.gif)
 
-## Step 1 @fullscreen
+## {Step 1 @fullscreen}
 
-Make the screen ``||basic:show an icon||``  of a **Heart**.
+Use the basic ``||basic:show icon||`` function to display the **HEART** icon. Type the code below, or drag a code snippet from the ``||basic:Basic||`` Toolbox category.
 
 ```spy
 basic.showIcon(IconNames.Heart)
 ```
 
-## Step 2
+## {Step 2}
 
-After the icon is displayed, ``||basic:clear screen||`` and  ``||basic:pause||`` for `500` milliseconds.
+Use the ``||basic:clear screen||`` function followed by the ``||basic:pause||`` function to turn off the lights for **500** milliseconds (or half a second).
 
 ```spy
 basic.showIcon(IconNames.Heart)
@@ -27,9 +26,9 @@ basic.clearScreen()
 basic.pause(500)
 ```
 
-## Step 3
+## {Step 3}
 
-Now, copy the code currently have and add it to the end. In the copied code, ``||basic:show an icon||`` of a **SmallHeart**. Your heart will flash from big to small.
+Copy the code you've written and paste it at the end. In the copied code, change the ``||basic:Icon Names||`` to a **SMALL HEART**. Run your code in the on-screen micro:bit simulator. Do you see a big and small heart animation?
 
 ```spy
 basic.showIcon(IconNames.Heart)
@@ -40,23 +39,9 @@ basic.clearScreen()
 basic.pause(500)
 ```
 
-## Step 4
+## {Step 4}
 
-Add one more ``||basic:show icon||`` at the end to display another **Heart**.
-
-```spy
-basic.showIcon(IconNames.Heart)
-basic.clearScreen()
-basic.pause(500)
-basic.showIcon(IconNames.SmallHeart)
-basic.clearScreen()
-basic.pause(500)
-basic.showIcon(IconNames.Heart)
-```
-
-## Step 5
-
-Do you want your heart to flash continuously? Remove the last ``||basic:show icon||`` and then put a ``||basic:forever||`` loop around your code.
+Now let's make our hearts flash forever! Put a ``||basic:forever||`` loop around your code.
 
 ```spy
 basic.forever(function() {
@@ -69,6 +54,6 @@ basic.forever(function() {
 })
 ```
 
-## Step 6
+## {Step 5}
 
-If you have a @boardname@ connected, click ``|Download|`` and transfer your code to the @boardname@!
+If you have a @boardname@ device, connect it to your computer and click the ``|Download|`` button. Follow the instructions to transfer your code onto the @boardname@ and watch the hearts flash!  ⭐ Great job! ⭐ 

package/docs/projects/spy/love-meter.md

@@ -2,48 +2,66 @@
 
 ### @explicitHints true
 
-## Introduction @unplugged
+## {Introduction @unplugged}
 
-Make a **LOVE METER** machine, how sweet! The @boardname@ is feeling the love, then sometimes not so much!
+How much love 😍 are you emitting today? Create a 💓 LOVE METER 💓 machine with your micro:bit!
 
 ![Love meter banner message](/static/mb/projects/love-meter/love-meter.gif)
 
-## Step 1
+## {Step 1}
 
-Add an event to run code when ``||input:pin 0 is pressed||``. Use the ``P0`` touchpin.
+Add an input ``||input:on pin pressed||`` function to run code when Pin P0 is pressed on the micro:bit. Type the code below, or drag a code snippet from the ``||input:Input||`` Toolbox category.
 
 ```spy
 input.onPinPressed(TouchPin.P0, function() {
 })
 ```
 
-## Step 2
+## {Step 2}
 
-Put code into the ``||input:pin 0 is pressed||`` event to ``||basic:show||`` a ``||Math:random number||``
-between `0` to `100` when pin **0** is pressed.
+Write some code to show a number in the ``||input:on pin pressed||`` function, using the basic ``||basic:show number||`` function.
 
 ```spy
 input.onPinPressed(TouchPin.P0, function() {
-    basic.showNumber(randint(0, 100));
-});
+    basic.showNumber(0)
+})
 ```
 
-## Step 3
+## {Step 3}
 
-Click on pin **0** in the simulator and see which number is chosen.
+Instead of showing 0, use the ``||math:randint||`` function to show a random number between a minimum and maximum value.
 
-## Step 4
+```spy
+input.onPinPressed(TouchPin.P0, function() {
+    basic.showNumber(randint(0, 10))
+})
+```
+
+## {Step 4}
 
-Insert code to ``||basic:show||`` the ``"LOVE METER"`` message on the screen when the program starts.
+Everyone knows that love can be measured on a scale of 0 to 100. So, in the ``||math:randint||`` function, change the maximum value to **100**.
+
+```spy
+input.onPinPressed(TouchPin.P0, function() {
+    basic.showNumber(randint(0, 100))
+})
+```
+
+## {Step 5}
+
+Now let's be sure to label our Love Machine! Use the basic ``||basic:show string||`` function to show the message "LOVE METER" on the screen of the micro:bit.
 
 ```spy
 basic.showString("LOVE METER")
 input.onPinPressed(TouchPin.P0, function() {
     basic.showNumber(randint(0, 100));
-});
+})
 ```
 
-## Step 5
+## {Step 6}
+
+Let's test our code. Press **Pin 0** on the micro:bit on-screen simulator (bottom left). Numbers between 0-25 = 🖤 No Love, 26-50 = 🫶 BFF Love, 51-75 = 💘 Brokenhearted Love, 76-100 = 💖🔥 Fiery Hot Love!
+
+## {Step 7}
 
-Click ``|Download|`` to transfer your code in your @boardname@. Hold the **GND** pin with one hand
-and press pin **0** with the other hand to trigger this code.
+If you have a @boardname@ device, connect it to your computer and click the ``|Download|`` button. Follow the instructions to transfer your code onto the @boardname@. Once your code has been downloaded, hold the **GND** pin with one hand and touch the **0** pin with the other hand. Your micro:bit 💓 LOVE METER 💓 machine will detect the love current flowing through your body!