Catch the Star! - A Scratch Project

Over the past several weeks, I have been working with my child's classroom, focusing exclusively on Scratch! The kids LOVE it! :) We have been focusing mainly on game design, and of course, I try to make connections with the classroom syllabus at the same time. The class has been learning about the coordinate system and algebra over the last 2 months, hence the projects that I developed focus mainly on these two concepts.

I provided this sample program to get things started: Catch the Star! We went over the sample code and then the kids developed their own games using the concepts learned.

Aim:

Create a game where a sprite constantly glides from one end of the screen to the other (much like the chimneys in the popular Flappy Bird game on code.org). If another sprite hits it, you get/lose a point. 

S4A (Scratch for Arduino) Project - Robot Car Part 2 - Indicator Lights

Continuing with the previous project of the keyboard controlled robot car and adding indicator lights to it... This is a really simple addition to the robot car, just a few LEDs to act as the car's indicator lights. And modifying the program to blink the LEDs on left/right turns and on reverse.

Additional materials for the indicator lights:

• 4 LEDs (preferably, 2 each in the same color)
• 4 Resistors
• Jumper wires as needed

S4A (Scratch for Arduino) Project - A Math Game using LEDs: Version 1, with 2 Sprites

Here is a Math game that uses LEDs to denote if answers in a Math Game are right or wrong. It's a follow-up on my previous Scratch project, A Simple Math Game in Scratch, with the addition of the Arduino hardware to Scratch.

We shall use the S4A development environment, which is quite similar to Scratch from MIT, except for the addition of a few instructions for interacting with the hardware. The Arduino board itself is represented as a Sprite in S4A, making it easy to use hardware specific instructions. We shall write the code for the Math game first and then modify it to include LED blinks to represent right and wrong answers.

Hardware:

• Arduino board
• USB cable to connect the Arduino to your computer
• Breadboard
• 2 LEDs of different colors (I used green & red)
• Jumper wires
• Resistors

Computer Science Concepts newly introduced:

• Using variables for communication among Sprites

The Design Process:

Let's start with a simplified version of the previous Math Game. Just as in my original version of the game, we need a Sprite to ask the Math questions. I have chosen the exact same Sprite (a starfish) and background (a seabed) in S4A to keep it as close to the original as possible. The design for the first Sprite - the starfish - follows the same process as in the previous version; the details can be found here.

The other Sprite we need is, of course, the Arduino board, to make the LEDs blink. While writing the program, try to confine all the hardware related stuff to the Arduino Sprite, and let the other Sprite (the starfish) handle the process of asking the questions & checking for their correctness. The Arduino Sprite shall blink the LEDs, similar to our previous Blink project. Keep in mind that we shall be using a couple of LEDs here, hence you need to modify the code a bit. The wiring shall also have a couple more components; more on that later...

The starfish shall ask the pre-decided questions, check the answers and keep track of the game scores. Just as in the original version, we shall use two variables - CorrectAnswers & WrongAnswers - for the game scores. I prefer to leave them visible on the screen to let the students see how the variables change during the course of the game. While creating variables, always try to provide meaningful names, it's useful for reading and comprehending your code later on.


Now, the big question:  how will the Arduino know when to blink the LEDs?


For this, we need to link the two Sprites together. Everytime the starfish Sprite finds out that an answer is correct, it needs to let the Arduino board know... One way of doing this is to set a flag & let the Arduino constantly check it... Here's what we shall do:  Create a new variable, say "right", and initialize it to 0. Make sure that when you create this variable that you choose the option "For all Sprites". This is to make sure that this variable is visible to the Arduino Sprite (in tech jargon, using a global vs a local...)


The starfish shall set the value of "right" to 1, everytime an answer is correct. Now, all our Arduino needs to do is check the value of right and blink the corresponding LED, say green...
 "if right is equal to 1, blink the green LED".


We can easily extend this principle to include another LED in our game - one that blinks if an answer is incorrect. Create another variable, say "wrong" along the same lines as "right". The starfish shall set the value of "wrong" to 1, everytime an answer is incorrect. The Arduino shall check the value of wrong as well and blink the corresponding LED:
"if wrong is equal to 1, blink the red LED".

Now our game looks quite interesting... Just like in a real quiz show on TV, we have different LEDs that light up depending on the correctness of the answer...


Here's the code on the Arduino Sprite side...


We have a forever loop where the Arduino is constantly checking the values of the variables "right" and "wrong". You might remember that we used Pin 13 in our previous Blink project to connect the LED. We shall use Pin 12 and Pin 13 here, since we have two LEDs.

You can see that after lighting up an LED, we wait a couple of seconds and then switch it off, similar to the Blink project. But, you also notice that we set the flag/variable "right" (or "wrong", as the case may be) back to 0, each time. This is to ensure that we set and reset the flag for every answer in our Math game.

What happens if we do not reset the flag? The value of "right" will always stay at 1, after the first time an answer is correct. So your green LED will keep on blinking. Similarly for the value of "wrong"... This results in incorrect hardware behavior -- you would not get the results that you wanted or expected... Hence, it's important that you reset the values of the flags. Again, I recommend that you leave the variables visible on the screen so that the students can see how the values change over the course of the program.

Wiring:

The wiring involved is pretty simple. Two LEDs, green and red, connected via resistors to Pins 12 and 13. I have used the green LED connected to Pin 13 to represent the correct answers, and the red LED connected to Pin 12 to represent incorrect answers. As mentioned in our previous Blink project, the resistors are used to ensure that the LEDs do not get burned out by high currents from the board. Both the LEDs have their positive (longer) legs connected to Pins 12 and 13. Their negative (shorter) legs are connected to the GND (Ground) on the Arduino via a jumper wire.

Putting it all together:

Here are the screen shots of the (simplified) Math Game...

Code for the Starfish Sprite: I start by initializing all the variables to be used, followed by a short conversational intro to the game. Next come the questions in our Math quiz: ask the question, wait for the answer, check its correctness and then set the variables accordingly. Notice that we "change" or increment the CorrectAnswers/ WrongAnswers, while we "set" our flag variables right/ wrong to 1.

The code for the Arduino Sprite... I choose to hide this sprite (via the "hide" instruction) for aesthetic purposes; you probably do not want the board to show up on the screen along with the starfish... The "wait" instruction is purely optional; it corresponds to the time taken by the starfish's conversational intro... 

And a snapshot of the screen with the variables...

Testing:

Time to test the code and see if our Math Game works...  Test with as many combinations of the answers as possible: 4 combinations of answers in the above case (Right-Right, Right-Wrong, Wrong-Right, Wrong-Wrong).

Now, click on the green flag at the top of the screen, play the game and watch the LEDs blink!

Blink 2 - An S4A (Scratch for Arduino) Project using a Breadboard & an LED

This is version 2 of Blink, where we shall see how to use a solderless breadboard to connect an LED to the Arduino. Learning to use breadboards is very fundamental to building circuits. The S4A (Scratch for Arduino) code we shall use here is exactly the same as in the previous Blink project. And the exact same blink functionality for the LED will be developed, but using a different wiring this time involving a breadboard.

Why use a breadboard? A breadboard is a quick, easy way to prototype a circuit. It allows you to experiment with electronic circuits, build and test them without any soldering. It can be used to build the simplest of circuits to very complex ones. You can read more about breadboards here and here.

Back to Blink2... We shall connect the LED to Pin 13, just as we did in Blink version 1. The S4A code for blinking the LED turns it on and off, with an interval of 1 second, to provide the blinking effect.

Here's the wiring we shall use for Blink2 with the above S4A code:

As you can see from the image, the LED is placed on the breadboard this time, rather than connected directly to the board as in Blink version 1. We use a resistor to connect the positive leg to Pin 13. The negative leg is connected to the GND (Ground) via a jumper wire. (Both jumper wires and resistors come as part of the Arduino kit. You can also buy them in bulk at stores such as Fry's, RadioShack, Amazon, etc.)

Here, we take advantage of the fact that all the components in a row on either side of the ravine on a breadboard are electrically connected. We connect one leg of the resistor to the same row as the positive leg of the LED, and connect the other leg of the resistor to Pin 13. The resistor is used to limit the electric current flowing in to the LED, and to ensure that the LED does not burn out due to direct power from the Arduino. The jumper wire from the Arduino GND (Ground) is connected to the same row as the negative leg of the LED, to complete the circuit. The electric current will flow in to the LED from Pin 13 through the resistor and flow out to the GND (Ground), thus completing the circuit.

Now, click on the green flag on the S4A screen and watch the LED blink...

Doodle Pencil - Using the Pen & Mouse Pointer Coordinates in Scratch

Here's a fun little Doodler made with Scratch:  The Doodle Pencil
















This was rather a spur-of-the-moment project... inspired by Etch-a-Sketch...  and kind of a follow-up on the Pac-Man game...

The code is minimal, and I feel not much of an explanation is required. The instructions are mainly from the Pen area of the Scratch Instruction Set, along with the instruction to follow the mouse-pointer. The "green flag click" handler does the initialization - clearing the screen, setting the sprite size and setting up the pen size & color.

The code is interactive, and it's designed to enable the user to lift and lower the pen as required while doodling: Move the mouse pointer to the desired location on screen and then click on the up arrow key; the pen will start drawing now by following the movements of your mouse pointer. Click on the down arrow key to stop drawing at any point.

This could be a fun little exercise for the kids to see how different combinations of the "Pen" and "Motion" instructions interact with each other.

Enjoy doodling!

CopyCat - A Simple Intro to User Input and Variables via Scratch

My child and I worked on CopyCat as a simple introduction to variables and user input in Scratch. Algebra is part of the Grade 4 Math curriculum in the USA, and this project could be a fun way to introduce the use of variables.

Aim:  

Design an interactive game in Scratch, where a CopyCat copies/repeats everything that you type in.

The Design Process:

• Only a single sprite is required: the CopyCat. You can either choose from the list of sprites already available on Scratch, or draw your own. 

• To provide user interaction in starting and stopping the game, we used the "green flag click" to start and the "space key click" to stop the game (both of which can be found under the section "Events" in the Scripts area in Scratch). You can choose any of the options that are available in "Events" to do the same.

Various sections in the Scripts area of Scratch

And now the fun part: CopyCat needs to copy everything that you type in.
How can we achieve this?

• Under "Sensing" in the Scripts area in Scratch, you will find a block that asks for user input and waits for it. This is what we shall use, to ask the user to type in anything they like.

• Once the user input is received, CopyCat needs to repeat it. But, how can CopyCat remember what the user typed in? Here is where the concept of variables comes into play. In the section "Sensing", you will find the variable "answer", which stores whatever the user typed in. 

• I recommend selecting the box right next to "answer", so that it is visible on the screen and the kids can see how its value varies (hence the name variable), depending on the user input.

• The CopyCat can now use this variable along with the "say" instruction (found in the "Looks" area of Scripts in Scratch), to repeat/copy whatever the user types in.

Ask the students to try writing the code upto this point:

1. When "green flag clicked" (or other event), CopyCat asks the user to type in something.
2. CopyCat repeats the user input, via the variable "answer". 
3. When "space key clicked" (or other event), stop the program.

Let the students experiment with different values for the user input and observe how the variable changes accordingly. Once comfortable with the use of the variable, they can hide it by deselecting the box next to "answer".  It would be good to remind the students at this point, that this feature is helpful for debugging.

Here are three screen shots to demonstrate how the user input gets stored in the variable "answer".

  Asking for user input; variable is empty

User input entered; variable is empty till Return key is pressed

User input is now stored in the variable

Pac-Man is Chasing my Planet!

My child's class was recently introduced to Cartesian coordinates in Math. And in our coding class, we have been practicing interactive programming for the last few weeks. So, I thought of putting together a very simple template that  combines both the concepts, that the kids could then remix...  Pac-Man is Chasing my Planet! was the result... took me less than 10 minutes to put together and the kids loved it.

We went through the Pac-Man template code as a group & discussed the use of the XY coordinates. I showed the kids how the XY coordinates displayed under the Scratch animations area change, as I move the cursor around on the screen. Our discussion then proceeded along the following lines:

• If I wanted my sprite (the planet, in this case) to move anywhere the cursor moves, what values should I use for the sprite's X and Y coordinates? 
• The above point was also a good place to talk about variables, and how the change of the cursor position is always reflected in the planet's position. 
• Should I move the planet around for just a few times or all the time? What kind of a loop should I use here?
• How can I make Pac-Man always follow the planet? Which loop should I use? 
• What values should I use for Pac-Man's X and Y coordinates? 
• Here, the kids quickly saw that without a small degree of separation between the coordinate values of the planet & Pac-Man, the two sprites overlap each other.
• BTW, the "if-else" clause was purely optional, for those to wanted to add another level to their game. The majority went with just a "go to x() y()"
• And finally, the interactive part of the game... I put in the requirement that there should "a key press" or "the green flag click" to make the game start, and something similar to end the game. 

In the next one hour, the children came up with multiple variations of the game, making their own sprites and designing various versions of tag... All in all, a very fun class for them and me to wrap up the school year.

Happy Summer!!