In this lesson you'll learn how to wire up a button to Marty's Raspberry Pi and then write some code to create a reaction to the button being pressed.

Marty the Robot with a Raspberry Pi - Instructions for that found here: 

https://robotical.io/learn/article/7/Adding%20a%20Raspberry%20Pi%20to%20Marty/Introduction/

https://uk.rs-online.com/web/p/push-button-switches/7346704/

https://www.amazon.co.uk/Conductor-Female-Jumper-Color-

How to write code to react to button presses

Some help will need to be given to strip the cables

The first thing we have to do is wire up our button

Strip one end of your cable to expose the copper wire. Make sure you leave the female end on (the one with the hole) as this will be plugged into your Pi

Loop the copper ends of your cables through the holes in your button like this. Twist them both to make them secure. Make sure they're not touching!

Pass the cables through the front of Marty's mouth. You can use Blu-Tak to secure your button in place,

Now wire the female end of your jumper cable into your Pi on the pins shown below. You are connecting to the 5 volt pin and pin number 2,

Once our button is in place we then have to write the code to make Marty react to the button press.

Using your preferred Python editor, type in the below code. Remember to change the IP address (192.168.x.x) to your Marty's address (you can use the 

 to find out the IP address of your robot).

The code below sets up pin number 2 as an input and constantly (

import martypy, time, RPi.GPIO as GPIO commandNumber = 0

GPIO.setwarnings(False) GPIO.setmode(GPIO.BOARD) GPIO.setup(2, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) #insert the IP address for the Marty you want to connect to marty = martypy.Marty('socket://192.168.xx.xx') marty.hello() marty.eyes(100,1500) time.sleep(1) while True: if

GPIO.input(2) == GPIO.HIGH: if commandNumber == 1: marty.celebrate() elif commandNumber == 2: marty.circle_dance('left', 4000) elif commandNumber == 3: marty.circle_dance('right', 4000) commandNumber = 0 #if at number 3 - set it back to number 0 commandNumber = commandNumber + 1

We're now going to try extending the code to do more actions.

Add some more code to your program so that if you push the button 4 times Marty waves the right arm.

Where will the code for setting the commandNumber back to 0 go?

The code below is required for waving Marty's right arm

Now, can you change the angle of the move and the time it takes to complete the action?

GPIO.setup(2, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

#insert the IP address for the Marty you want to connect to

marty = martypy.Marty('socket://192.168.xx.xx')

commandNumber = 0 #if at number 4 - set it back to number 0

Using what you've learned in this task and previous tasks, think about how you might extend this code futher. Can you:

Add another button into Marty to perform a different type of action?

If you're thinking about wiring in more buttons to Marty you'll have to consider where you're going to place your pins on your Raspberry Pi. Using the image below you can decide where to place your cables. You'll need to use one of the 3.3v pins and then choose a GPIO pin

Using the Python documentation on the link below can you extend the program to do different actions?

You have now learned how to wire a button to your Raspberry Pi and write Python code to make the button do something. Why don't you now try:

Wiring buttons into each of Marty's hands to perform different actions

Giving Marty a Button

Using Scratch 3, you will create an interactive, multiplayer fishing game where different sea creatures will appear on the screen and, using bump switches, you have to beat your opponent to quickly tell Marty when to try and catch the fish.

To start off the game, Marty will raise the arm slightly and when some fish appear on the Scratch stage you need to press a bump switch to tell Marty to lift the fishing rod and catch the fish!

Paper for creating a paper fish for Marty

String to attach the paper fish to Marty's hand/fishing rod

How to detect force using bump switch sensors

How to create an interactive game on Scratch using both Marty and the Scratch stage

How to add different Scratch sprites and backgrounds to a project

Controlling sprite movements and appearances

This tutorial enables students to explore moving Marty's individual body joint and how to use force sensors. It also introduces sprites and backgrounds and gives students the opportunity to make an interactive game using blocks from many different code drawers.

It would be nice if Marty looked the part for our fishing game, so let's make a paper fish on a fishing line for Marty to pull when a fish on the screen is caught!

Draw out a paper fish, colour it in and cut it out,

You will then need to make a hole near the top of the fish and thread some string through the hole. You can then attach the string to Marty's hand so that it looks like we really are ready for some fishing!

The first thing that we have to do is create an underwater theme on the Scratch stage section of the screen.

Create a new Scratch 3 project with the Marty the Robot extension added.

Change the backdrop of the stage to be something with an under the sea theme.

We now need to select a new sprite - a fish sprite for Marty to try and catch ! This is very similar to changing the backdrop except we use the button beside the backdrop one and search again like before. Once you have added your sprite your stage should look something like this (don't forget to delete the Cat Sprite):

: You can change the size of your fish sprite by making the number in the

It would be no fun if the fish was always there ready for us to catch! Let's make things a little more interesting so that when we start the game, the fish will be hidden and then randomly appear.

Before we start the game, we want to make sure that the fish isn't visisble to the player! To do this you need to change the setting for the sprite so that it isn't showing,

Okay, so now we have no fish on our screen. When we start the game, by clicking on the green flag, we want the fish to wait for a random length of time between 1-6 seconds and then show itself:

: Play around with the different times you have to wait for the fish to appear? Is 6 seconds too long or not long enough?

We already have our fish appearing after a random amount of time but when it does appear it sits still. Wouldn't it be good if our fish could swim around the screen randomly?

Add a few extra blocks to your program so that when the fish appears on the screen, it starts swimming around. You might want to think about the following,

You might need to make another block of code starting with 

 block that tells the fish sprite to keep swimming around to random positions

If you get stuck remember that you can click below to see the answer. Test your code to see if it works!

Coding the fish keep swimming around the screen at random can be done in lots of different ways. We chose to use both the 

Using the bump switches on Marty's feet we can program Marty to react whenever the switch being pressed. We can make Marty react to this by pulling its arm down to reel in a fish!

To prepare Marty to catch fish we need to get ready and move the fishing arm outwards.

Next we will put our Move right arm block inside an 

 Loop and add another Move right arm block at the end:

Can you remember which GPIO input you plugged the bump switch into for Marty's right foot?

In this example we plugged it into GPIO input 0. We've added an 

 statement so that if the bump switch is pressed ('GPIO input 0' = 1) then Marty will pull their arm inward and then put the arm back into the fishing position again at the end.

 here so as soon as Marty has reacted to the switch they will go back to waiting until the bump switch is pressed again before moving the arm:

Try testing it out! Does Martys arm go down and then back up each time you press the bump switch?

STEP 5: Checking if We Really Caught a Fish & Scoring a point!

From testing your program, you might have noticed that anytime you push on the bump switch, Marty can try to catch a fish regardless of whether the fish is on the screen or not. We should probably make Marty check that there is a fish on the screen to be caught before celebrating or being able to score a point in our game!

In order to know whether the fish is on the screen we will need to keep track of when it is and isn't visible on the Scratch stage. We can do this easily using a variable!

Create a new variable and set it to be 0 when we start the program,

Using the same code as we made earlier for the fish sprite

 set the variable to be 1 after we set the fish to be visible on the screen. That way we know that when the variable is 0 there are no fish on the screen and when it is 1, there is a fish on the screen!

Next we should make the fish wait for Marty to get ready before appearing by adding a 

 to make sure the fish appears and the dissapears again.

 before hiding so we have a chance to catch it too!

 to make a different fish appear after the last one has appeared and dissapeared again, then we can catch lots of different types of fish!

The code for your fish should now look like this:

Now we can change the code we made earlier so that when the switch that tells Marty to try and catch a fish is pressed, we will stop Marty moving the arm unless there is also a fish on the screen at the same time.

 so that we can have more than one condition being checked in our if statement. We will also need to another 

block for visible fish = 1 as shown here:

In Scratch, we can run programming blocks in 

, meaning that we can do more than one thing at a time. By using the same event block at the top of our sequence of coding blocks, we can run two individual sequences at the same time. We will need to do this to get a swimming fish. Whilst we are doing the set-up we can also just tell the fish to start randomly swimming around in the background whether it is visible to the user or not.

In order to start scoring points whenever we catch a visible fish we will need to create another variable called 'Player 1 Score'!

Set it to zero at the start of the game before Marty Gets Ready

 block to increase it by 1 when we catch a fish. This happens when the right arm moves after the code for [GPIO input 0 = 1] AND [visible fish = 1]

Now would be a good time to test your code! Does your score go up by 1 when you push a bump switch in at the same time a fish is visible on the screen?

Now that we know we can score points when we catch fish, wouldn't it be fun if we can have a competition with a friend to see who is the fastest to catch the fish? First to catch 5 fish wins!

So far we have 1 person playing the game with the right foot bump switch and the right arm for fishing. To add another player we will need to use another bump switch (we are using GPIO input 1) for the left side of Marty!

We will need to create a new variable called 'Player 2 score':

Now we need to code Marty's left foot bump switch (the one player 2 will use) to respond to being pressed. Rather than coding all the same commands that we did for Marty's right arm all over again we can simply right click and duplicate those blocks to save time:

We then need to remember to change the blocks from right arm to left arm 

 that we made, don't forget to use our new player 2 score variable as well:

Now that we can score points whenever we catch fish, and now that we have another player in the game, it is time to see who is the fastest to catch the fish. Let's make some code so that the first person to catch 5 fish wins and makes the game stop running!

First we need to create 2 new backdrops to show different game over screens for player 1 winning and for player 2 winning. We will do this by clicking on the small picture of the backdrop on the right side of the screen in Scratch. After clicking that we will click on the backdrops tab in the top left (above the list of code blocks):

Going Fishing with Marty

We introduced bump switches in Activity 8 and gave a brief overview of some of their possible uses. In this activity we will detail how bump switches can be used to stop your Marty from walking off the edge of a table, or accidentally taking a stage dive!

Find out how to save Marty from falling off a table! It's all thanks to the humble bump switch.

Through example code, this activity presents another example of how to use bump switches to sense when Marty is about to fall off an object!

Connecting the bump switch to Marty’s foot

To detect if Marty is about to walk off an edge we need the bump switch to be positioned at the front of the foot on the bottom, as shown in the photo below.

It can be quite fiddly to attach the bump switches however don't let this worry you - after attaching our fair share of bump switches we have some top tips!

It is easiest if you remove Marty's foot before you add the bump switch.

Take two of the small M2 bolts (these are the longer, thinner bolts included with Marty)

Thread them through the holes in the bump switch

Now attach the M2 nuts to the end of the bolts, but only screw them on a very small amount, leaving a gap between the bump switch and the nuts, as shown in the picture on the left below

Position the bump switch on the bottom of Marty's foot as shown. Make sure the bolts are lowered into the two grooves as in the picture

Tighten up the bolts securing the bump switch in place

Reattach the foot to Marty (and check that the spring is on the correct side)

For this activity, you need to place a bump switch on the bottom of Marty’s foot, as shown in the image below, and connect it to port 0. For more detailed instructions on how to do this, see Activity 8.

 to check if the bump switch is pressed at the end of each step.

 block allows you to read the current state of a switch. By assigning what the 

) will read 1 when the bump switch is pressed and 0 when the bump switch is not pressed. Set 

 to take the value of the output from the bump switch using the 

You need this short section of code to run at the same time as other code that you write to control Marty.

 to detect whether Marty’s foot is touching the ground.

At the end of each step Marty takes, we can check to see if the bump switch is pressed. If it is pressed, Marty is standing on firm ground and the 

However, if Marty is about to step into thin air 

 will read 0, indicating Marty has come to an edge. When this happens Marty will no longer take steps forward and instead will look angry!

Start both sections of code by clicking on the 

Once Marty has detected the danger of being about to step off an edge it would be useful if Marty reacted appropriately rather than just looking angry!

Make the code below . This will program Marty to 

 around when encountering an edge. The outer 

 allows Marty to walk to an edge 4 times before giving up! And there are appropriate Marty eye movements of course... 

You have written many activities worth of code now so will be becoming an expert in Scratch. Try to work out and explain what each part of the code does. You could try making Marty do different moves when getting to the edge - just keep a hand ready to catch Marty if it goes a bit wrong!

So far we have thought about Marty losing contact with the ground by stepping off an edge into thin air. Another way that Marty could lose contact with the ground is if Marty is lifted up. Can you set an alarm so that if someone picks Marty up and tries to take Marty away they will get a big surprise?!

Code a routine so that if Marty's feet lose contact with the ground, an alarm sounds! Here are a few things you will need to think about,

What is Marty going to be doing until picked up? Standing still? Going round in circiles?

What sort of noise do you want for your alarm? 

Will anything else happen when Marty is picked up?

You have now just programmed Marty to react if the bump switches lose contact with the ground. If you want to continue to explore this idea, here are a few ideas!

Each Marty comes supplied with two bump switches, how can you prevent Marty stepping off a platform when walking sideways?

What about preventing Marty walking off backwards?

Going Over the Edge

We used Scratch 3 to program a micro:bit to be a Marty remote control!

, so you can download it and try it out yourself. Read on to discover some more simple tips and tricks, and an explanation of what the code does...

Tilting the micro:bit steers Martys around, while the buttons can be used to make him kick and wiggle. We can also use the LEDs on the micro:bit to show things, like the battery level on Marty!

This is a fun project in Scratch 3, and makes use of a Bluetooth connection to the micro:bit, so you don't need to have the micro:bit connected to your computer!

Getting started is really straightforward, but we'll also take things a bit further to show off how some snazzy programming can make a smarter remote control!

First off, you'll need a micro:bit, a Marty, and the Scratch 3 beta with Marty Extension at 

 to install Scratch link and set up your micro:bit to be ready for Scratch

Power up the micro:bit and your Marty, in the normal way

 and load the Marty and micro:bit extensions, like shown in this video:

Ok! Let's start super simple, and get our Marty, micro:bit, and Scratch 3 working in perfect harmony. Look in the micro:bit blocks section and the Marty section to find these blocks, and connect them together:

Now, when you press the A button on the micro:bit, Marty will get ready and wiggle his eyebrows! Cool!

As well as using the micro:bit as input, we can also use the LED screen on the microbit. Adding an extra block we can say Hello too!

As well as knowing when the buttons are pushed on the micro:bit, we can use the tilt sensing to steer Marty around! A simple remote control might look like this:

We want to use the A and B buttons to kick the left and right legs, so we need to find another way to get Marty ready. Here I've used the "when shaken" block to make Marty wake up and get ready when the micro:bit is shaken!

Tilting the micro:bit forwards or backwards will make Marty walk forwards or backwards a couple of steps. Tilting left or right will product sidesteps.

It might be nice to get some more feedback from the program, so let's get it to tell us what Marty is doing:

This uses the Scratch 3 block to display a pattern to the screen on the micro:bit. We've drawn arrows here, but you could use whatever you want!

That program will definitely work, but what happens if you tilt the micro:bit diagonally? Marty might take a couple of steps forwards, then sidestep, or the other way around maybe... it's hard to know exactly what will happen, as the micro:bit is tilted both front-ward and left at the same time.

To make this easier to use, we're going to make it so Marty will walk and turn at the same time, turning more or walking further as you tilt the micro:bit more

We're going to use a single "When titled" event for this, and a couple of variables! You can make a variable using the "Make a variable" button inside the variable blocks:

We want to make two variables, one called 

We'll look at how the micro:bit is being tilted, set the 

 variables to match the turning and step length we'd like Marty to do, and then put those into a walk command

When the micro:bit is tiled, we're going to repeat this code until it's not tilted any more. This means if we keep the micro:bit tilted, Marty will keep on walking

We start by assuming the micro:bit is tilted more left than right, and set the variable `turn` to the amount of left tilt, which is a number from 0-100.

Next we check to see if that assumption was correct. If we were wrong, and the micro:bit is tilted more right than left, we change `turn` to use the right tilt instead. We need to say `0-tilt angle` since the Marty block will expect a turn value from -100 -> +100 (well, actually -128 -> +127)

We do the same thing with front and back tilt, so `length` ends up set to show how far forwards or backwards we should walk

We tell Marty to walk one step with the `length` and `turn` we just defined!

If you've tried the code above out, you'll see that you have to hold the micro:bit really 

 flat to stop it sending walk commands to Marty.

It would be better if we only sent a command if Marty actually had a reasonable size step to take:

This code is very similar to before, except we added in an 

 instruction, and we only walk if the combination of 

 variables passes a threshold. So that could be a 

, and refers to the magnitude of a number, rather than whether it is positive or negative. so 

, would also be 40! We need to do this so that when we compare 

 40, it will allow numbers 'bigger' than 40, whether they're positive or negative.

 in the code to make the controller more or less sensitive!

I also thought the step length was pretty large, so I divided it by two to give Marty a bit of a break!

I didn't actually spot this until I was filming the video above and I wondered why Marty wouldn't walk diagonally forwards in one direction.

But that's why testing is important, and we all learn by making mistakes!

 bit above, which is supposed to give a number that gets bigger as 

 gets bigger? Well, if one is positive, and one is negative, they'll cancel each other our when we add them, and 

 to make sure the numbers were each positive before I summed them. Like this:

Ok, with that fixed though, the tilt control works well!

We can use the buttons to kick, but it would be cool if we could make Marty wiggle if we pressed them both at the same time, to celebrate scoring a goal after kicking a ball maybe!

Unfortunately, there isn't a 'when both buttons pressed' block for the micro:bit in Scratch 3 yet. So we'll have to make one!

 sections, we'll have just one section that deals will all button pressing!

We wait for 0.1 seconds. That's because even if you try really hard, you probably won't press both buttons the exact same instant. This gives a bit more time to see if both buttons have been pushed before deciding what to do

Now we check to see if both buttons are pushed, using an `and` block, and if they are, we wiggle!

If both buttons weren't pushed, we check if the A button was pushed, and if it was we kick the left leg

If it wasn't, then the B button must have been pushed, and we'll kick the right leg instead

In a long session of Marty football, it would be great to know how much battery your Marty has, and we can use the micro:bit to show that!

 Marty block to get Marty's battery voltage. (Pro-tip, this block will sometimes return 'null' - we're working on fixing it! - but to keep it active click the checkbox next to it in the Marty blocks panel, that'll also display it in Scratch!)

A fully charged battery voltage is 8.4v, and the low battery is 7.4v, so there's a range of about 1.0v that we'll make into a percentage! We subtract 7.4 from the battery voltage and multiply the result by 100. So 7.9v would become 

 block to join a '%' to the end of it when we display it.

I put that collection of blocks into the button section, so when you push both buttons at the same time Marty will wiggle, and then the micro:bit will display the battery charge percentage

Ok, that's the whole program as shown off in the video at the top, altogether it looks like this:

, so you can download it and try it out yourself!

Marty with Scratch & The Micro:Bit

Marty' Groovy Graphing

Using Scratch 3 and the distance sensor add-on, you will create an interactive program where you use information from the sensor to control a sprite on screen, extending the system to give you audio and visual information so Marty can help you perfect your parking.

Using information from Marty's distance sensor, an on-screen sprite will show you the position of an object from the distance sensor and tell you to move forwards or backwards until you are parked perfectly. You will add alarm sounds and Marty will help with arm signals!

Learning Portal

Giving Marty a Button

Going Fishing with Marty

Going Over the Edge

Marty with Scratch & The Micro:Bit

Marty' Groovy Graphing

Marty'S Perfect Parking

Marty's Balancing Act!

Marty's Random Story Maker

Marty's Robot Reeling