BrainPad C# Variables and Nested Statements
C#VARIABLES AND NESTED STATEMENTS
ContentsIntroduction2Overview2Guidelines2Arguments3Exercise3Integer
Variables4Changing Tones6The if-statement with
Variables7Exercise7Inspecting Variables8Exercise9Double
Variable10Returned
Values12Exercise12Strings13ToString()14Exercise15Finite while
loops16Exercise18Nesting19Exercise20
Introduction
The BrainPad circuit board is designed as a powerful educational
tool that can be used to teach everyone from kids, to college
students and professionals. Kids will start to learn programming
using Visual Studio, one of the most widely used professional
tools. College students and professionals that already know
programming can use the BrainPad circuit board to learn about
digital electronics and the connection between computing and the
physical world.
Overview
Students will learn about variables, strings, while loops and
nested statements.
Guidelines
Prerequisites: CS101
Ages 12 and up
PC setup with Visual Studio, .NET Micro Framework and GHI
Electronics software.
Supplies: BrainPad
Arguments
Arguments are values passed to methods. The following examples
list the different ways arguments can be used.
BrainPad.Buzzer.PlayFrequency(3000);
Example 1 To play a sound with the buzzer, we pass an argument
of 3,000 that represents the frequency to use.
BrainPad.Wait.Seconds(0.2);
Example 2 Here we tell the program to wait for 0.2 seconds
before continuing execution.
BrainPad.Button.IsPressed(BrainPad.Button.DPad.Down)
Example 3 The argument here uses an enumeration. The DPad.Down
enumerator contains named values that represent buttons. This
allows us to easily identify things by a descriptive name rather
than using numbers. In this case we check if the Down button on the
directional pad is pressed.
Exercise
Use the wrong argument types and build the project to observe
the error messages.
Integer Variables
A variable is a location in memory that is reserved for us to
use. Instead having to know where the memory is, the system gives
us access to that memory using a name we choose as shown in Example
4.
int count;
Example 4 Use we create an integer named count in the system
memory.
The above line instructs the system to reserve a variable that
is named count and the variable type is an Integer, or int when
coding.
A variable name can use any letters and numbers but it cannot
start with a number or contain spaces. Using the underscore symbol
is allowed.
The following are examples of valid and invalid names.
int count123;
int count_me_in;
int count2var;
Example 5 These are variable names that are valid.
int count me;
int count#;
int 2count;
Example 6 These variable names are invalid.
Variables in small programs can use any names. It could even be
just x. However, using a meaningful name is very important when
writing programs, as there maybe hundreds of variables in a large
program.
Variables can be used to store numbers as shown in Example
7.
int count;
count = 10;
count = 123;
Example 7 This variable is storing an integer.
Example 8 shows math can be used as well.
count = 5 + result;
Example 8 This shows a variable storing the result of an
equation.
Note that the variable can be used in the equation (Figure 9) as
well.
count = count + 2;
Example 9 Variables can also store values from equations that
contain themselves.
The above code will add 2 to the current value of count.
After selecting an appropriate name, an appropriate type is
needed. The type tells the system how much memory to reserve for
that one variable. The most widely used variable is an Integer,
which is 4 bytes and can hold large numbers and negative numbers.
For now, we suggest using Integers for everything, except when
fractions are needed (more on that later).
Changing Tones
We will start a new project and name it BrainPad_Project then
use the code shown in Example 10.
public class Program
{
int frequency;
int increment;
public void BrainPadSetup()
{
frequency = 0;
increment = 0;
}
public void BrainPadLoop()
{
if (BrainPad.Button.IsUpPressed())
{
increment = 100;
}
if (BrainPad.Button.IsDownPressed())
{
increment = -100;
}
if (increment != 0)
{
frequency = frequency + increment;
increment = 0;
BrainPad.Buzzer.PlayFrequency(frequency);
BrainPad.WriteDebugMessage(frequency);
BrainPad.Wait.Seconds(0.2);
BrainPad.Buzzer.Stop();
}
}
}
Example 10 This code uses the variables frequency and increment
to control the frequency of the pitch made by the buzzer. The
frequency increases when up is pressed and decreases when down is
pressed. Each press plays the new frequency for one-fifth of a
second.
As we use the up and down buttons to change the frequency, the
value held by the frequency variable is printed in the Output
Window. Using Example 10, can we determine the highest frequency a
person can hear?
The if-statement with Variables
The same way the if statement was used to check if a button was
pressed, it can be used with variables. If the frequency is larger
than 6,000 turn the red light on, otherwise turn it off. Add the
code shown in Example 11 to the while loop in Example 10, right
above the BrainPad.Wait.Seconds(0.2) line.
if (frequency > 6000)
{
BrainPad.TrafficLight.TurnRedLightOn();
}
else
{
BrainPad.TrafficLight.TurnRedLightOff();
}
Example 11 This code turns the red light on if the frequency is
greater than 6,000, otherwise it turns it off.
Pressing the up button will increase the frequency. Once the
frequency is greater than 6,000 the red light will turn on.
Exercise
Add a variable that starts at 0 and increments by 1 every loop.
Once the variable reaches 1,000 turn the yellow light on. Print the
variable value in the Output Window to make sure its incrementing.
Verify the yellow light comes on when the variable goes over
1,000.
Inspecting Variables
Printing the variable value worked well for small programs with
a single variable. It is not practical to continuously print every
variable out when it comes to larger programs. Instead, we can use
the debugger feature to pause the code and inspect variables.
public class Program
{
int count;
public void BrainPadSetup()
{
count = 0;
}
public void BrainPadLoop()
{
count = count + 1;
BrainPad.WriteDebugMessage(count);
BrainPad.Wait.Seconds(0.2);
}
}
Example 12 This code loops indefinitely, incrementing the count
by one each loop and printing its value in the Output Window.
Add a breakpoint to the loop in Example 12 and step through the
code. Move the mouse over the count variable and wait a second. A
pop up window will come up showing the value of the count variable
as shown in Figure 1.
Figure 1 Adding a breakpoint and placing your cursor over a
variable will pop up a window showing its value.
The Watch Window can also be used with important variables that
need to be inspected regularly. Locate the Watch Window and type
the variable name in the left cell. This will show the variable
value and type.
Figure 2 In the Watch Window we can add variables like count to
see their value and type as the program runs.
Exercise
Run Example 12 for a few loops, then pause the program, or add a
breakpoint. Inspect the value on the Watch Window. It should be
above zero. Change the value manually to zero and then re-run the
program and observe how the Output Window shows the variable going
back to counting from zero.
Double Variable
While an Integer can hold large numbers, it cant hold fractions.
For example, there is no way to set an integer to 0.5 or 123.8. The
variable type double should be used whenever fractions are needed.
If a double can hold large numbers and fractions, why not just use
it for everything? You certainly can but double type variables
require more memory and processing. Fractions are not always
desirable in the programming world as shown in Example 13.
public class Program
{
double frequency;
int increment;
public void BrainPadSetup()
{
frequency = 0;
increment = 0;
}
public void BrainPadLoop()
{
if (BrainPad.Button.IsUpPressed())
{
increment = 100;
}
if (BrainPad.Button.IsDownPressed())
{
increment = -100;
}
if (increment != 0)
{
frequency = frequency + increment;
increment = 0;
BrainPad.Buzzer.PlayFrequency((int)frequency);
BrainPad.WriteDebugMessage(frequency);
BrainPad.Wait.Seconds(0.2);
BrainPad.Buzzer.Stop();
}
}
}
Example 13 This code shows how a double isnt always the best
variable type choice. Instead of simply passing an integer into
PlayFrequency we have to cast it as an integer first. This is done
by placing (int) before the variable, which requires additional
un-needed processing.
Time to go back to our favorite green light! In Example 14, we
will turn the green light on and off for a specified amount of
time, set by a variable called delay. The up and down buttons
control the delay variable, causing the light to be on and off
longer or shorter. The variable is also printed out using
WriteDebugMessage(delay).
public class Program
{
double delay;
public void BrainPadSetup()
{
delay = 0.20;
}
public void BrainPadLoop()
{
if (BrainPad.Button.IsPressed(BrainPad.Button.DPad.Up))
{
delay = delay + 0.10;
}
if (BrainPad.Button.IsPressed(BrainPad.Button.DPad.Down))
{
delay = delay - 0.10;
if (delay < 0)
delay = 0;
}
BrainPad.WriteDebugMessage(delay);
BrainPad.TrafficLight.TurnGreenLightOn();
BrainPad.Wait.Seconds(delay);
BrainPad.TrafficLight.TurnGreenLightOff();
BrainPad.Wait.Seconds(delay);
}
}
Example 14 This code flashes the green light on and off. A
variable named delay controls how long the green light stays on and
off.
Returned Values
Some methods return a value, like when reading the light sensor.
This value can be placed into a variable and this variable can be
used with if statements. We have lightbulb and light sensor on the
BrainPad. Lets turn the light on when its dark as shown in Example
15.
public class Program
{
double level;
public void BrainPadSetup()
{
level = 0;
}
public void BrainPadLoop()
{
level = BrainPad.LightSensor.ReadLightLevel();
BrainPad.WriteDebugMessage(level);
if (level < 0.5)
{
BrainPad.LightBulb.TurnOn();
}
else
{
BrainPad.LightBulb.TurnOff();
}
}
}
Example 15 When the level of light drops below 0.5 we turn the
lightbulb on.
How can we determine what threshold to use to turn the lightbulb
on? This is a perfect example of when inspecting variables is
needed. Run the program and test it by placing a finger over the
light sensor to block the light. You may need to adjust the
threshold from 0.5 to something else. Take a look at the Output
Window to see the light levels to determine what value works best
for you.
Exercise
Modify Example 15 so the up button sets the threshold.
Hint: The threshold was a constant before but now it is going to
be a variable that is set to whatever the light sensor returns when
the button is pressed. Name the variable threshold and make sure
its a double.
Strings
A string is a type of variable that holds text as shown in
Example 16.
BrainPad.WriteDebugMessage("Hello World!");
Example 16 The text "Hello World!" is considered a string.
Its important to remember that the value 2 and the string "2"
are not the same thing. They may be the same to us but internally
in the system they are very different.
x = 2 + 2;
Example 17 When x is an integer, adding 2 + 2 means x equals 4
as you would expect.
Lets assume str is a string variable (Example 18), what is the
value of str?
str = "2" + "2";
Example 18 The plus sign symbol means something different when
dealing with strings. Using the plus sign to connect strings is
called concatenation. Which means a series of interconnected
things.
When concatenating strings in Example 18, the result is "22".
This will make more sense if you try Example 19.
str = "Hello number " + "2";
Example 19
The result is "Hello number 2". Note how even a space makes a
difference.
ToString()
One of the important built-in methods for variables is the
ToString() method. This method will take the value from count and
convert it to a string as shown in Example 20.
public class Program
{
double count;
public void BrainPadSetup()
{
count = 0;
}
public void BrainPadLoop()
{
count = count + 1;
BrainPad.WriteDebugMessage("Count: " + count.ToString());
}
}
Example 20 Cotinousely increase te count and display it as a
string.
Example 20 uses an integer that starts at zero and increments by
one in every loop. It also prints the variables value in the Output
Window (Figure 3). The text "Count: " is concatenated before the
value to give us these results.
Figure 3 The Output Window shows the program from Example 20
counting up.
C# is smart when it comes to concatenation. Try changing line 16
from count.ToString() to just count. C# knows to automatically call
the ToString() method internally as shown in Example 21.
BrainPad.WriteDebugMessage("Count: " + count);
Example 21 Concatenating numbers and other objects with strings
will automatically call the ToString() method.
Exercise
Show something like this (Figure 4) in the Output Window.
Figure 4 Here we see the light sensors level printed in the
Output Window.
Finite while loops
Loops have been used extensively in every example. The while
loop was always looping infinitely using BrainPad.Looping. This was
used to simplify things but BrainPad.Looping is just a true value
internally. In other words, the while loop will run while something
is true and since we have passed it the value true then it will
loop forever.
Is the statement in Example 22 true?
1 = 1
Example 22 This statement asks if 1 equals 1 and the answer is
yes, so its true.
Now we can make a while loop, loop forever using this statement
(Example 23).
public class Program
{
public void BrainPadSetup()
{
int count = 0;
while (1 == 1)
{
count = count + 1;
BrainPad.WriteDebugMessage("Count: " + count);
BrainPad.Wait.Seconds(0.2);
}
}
public void BrainPadLoop()
{
// Declared but not used
}
}
Example 23 Here we use the statement 1 == 1 to keep the while
loop running forever.
It should be noted clearly that we used == and not = in the
while statement. The single = is used to set a value (Example 24),
not compare them (Example 25).
int count = 10;
Example 24 This code sets count to 10.
if (count == 10)
Example 25 This code compares count with 10 to see if its
equal.
The Boolean type true can be used as well as shown in Example
26.
public class Program
{
public void BrainPadSetup()
{
int count = 0;
while (true)
{
count = count + 1;
BrainPad.WriteDebugMessage("Count: " + count);
BrainPad.Wait.Seconds(0.2);
}
}
public void BrainPadLoop()
{
// Declared but not used
}
}
Example 26 This code uses true in the while loop statement to
keep it running forever.
A while loop can also be finite (Example 27), meaning it will
stop looping at some point.
public class Program
{
public void BrainPadSetup()
{
int count = 0;
while (count < 10)
{
count = count + 1;
BrainPad.WriteDebugMessage("Count: " + count);
BrainPad.Wait.Seconds(0.2);
}
}
public void BrainPadLoop()
{
// Declared but not used
}
}
Example 27 This code will count up to 10 before the while loop
stops.
What did Example 27 do? It printed the count from one to 10.
However, the count started at zero, not one. Shouldnt it print
count zero? Looks like its time to start debugging. Start by
setting a breakpoint at count = 0 and then step in the code to see
what the value of count is (use Watch Window) and then see why the
value zero was never printed. Think about a fix before looking at
the next example.
The fix is easy as shown in Example 28.
public class Program
{
public void BrainPadSetup()
{
int count = 0;
while (count < 10)
{
BrainPad.WriteDebugMessage("Count: " + count);
count = count + 1;
BrainPad.Wait.Seconds(0.2);
}
}
public void BrainPadLoop()
{
// Declared but not used
}
}
Example 28 This code counts, printing zero to nine in the Output
Window.
What about the 10? Shouldnt the program print Count: 10? The
answer is in the while loop. In plain English, it says: run the
following code as long as count is less than 10. Since 10 is not
less than 10, then 10 will not be printed. The while loop can be
easily modified so 10 is printed too (Example 29).
while (count
