Current time:0:00Total duration:8:05

0 energy points

Studying for a test? Prepare with these 5 lessons on Lego robotics.

See 5 lessons

# Variable block (counter)

Video transcript

Here, I'm going to
show you how to build a simple counter, which is a
very important fundamental unit of many programs. Let's say we wanted the
ability for our robot to count the number
of claps which occur. So we had a sound
sensor, and any time it detected a sound level
let's say at or above 50, we count one, two, three,
four claps occurred. So to build something
like this, we need to understand how
the variable block works first and also the
constant block. The variable block, think of it
as a box which can hold a value and also allow you
to read that value. It's a little placeholder. Think of it as a
very basic memory. It can remember one thing. The other thing we
need to understand is the constant block. The difference between
the constant block and the variable
block is you can't write to the constant block. All you can do is read from it. So it can store a value,
such as say the number 1, and at any time you
can read this number 1. And you may wonder, what's
the point of this block? And you'll see in a moment. Now, we also need
the math block, and that's the heart of
the counting operation. Remember, the math block
has two inputs, A and B, and then it allows us to
do something with A and B. And in this case, we would
want to add A and B together. And it's the total result. So let's just think for a moment
before I wire this together. When you count, let's say
we are incrementing x. Every time we increment
x, we are actually doing this operation. We are saying x equals
whatever x was before plus 1. So if x is 0 at the beginning,
which let's say it is 0. The variable x, we wrote
0 to it at the beginning. The answer to x plus 0x
plus 1, if x is zero is 1. And if x was 1, the answer
would be 2 and so on. So for example, this
little operation let's build it using blocks. We would plug this constant
1 into our math block and then plug the
variable x into B. So now this math block is
doing x plus 1 every time, but x is going to be changing. And the output we
wire back into x. But I'm just going to draw x
here, because you can call up your variable in different
places in your program, and that's the powerful
thing to realize. We plug whatever the
result is into x, and let's say this is inside
a loop so it runs again. Let's just walk through it once. At first, 0 is fed into
the math block under B and 1 is fed under A.
So it does 0 plus 1, and then it spits out 1 into x. Then when it runs again,
this time the x provided will be 1, because remember
it's a little memory. So the math block
would say, oh, I got 1 and I always have 1 under part
A, and that will give me 2. And we write 2 to x. Next time it executes,
x will be 1 and 1 won't change-- I think you see
the pattern here hopefully-- and we write 3 to x. And this seems like a
complicated or convoluted way to add, but this is
the way it's done. So in our simple
example, let's say we had a switch statement here. And I'm not going to build
a full working program, just a subset of it, and
this was a sound sensor. And we had it setup, so
any time the sound sensor's greater than 50 I want to count. So let's just grab
our blocks you need. It's all under the data section. The constant block is the
suitcase with a lock on it, and that lock there
is to remind you, you can't write
to this suitcase. You can just give it a value
and it always has that value. The variable block
is the suitcase without the lock on it, and
this is our little memory. It can hold a value, we
can write a value to it, or read from it. And let's grab our math block. Remember we need to add
these two things together. Let me align this. And at the end of
the math block, we're going to put the value
back into our variable. Now, the most
important step here is to remember how
to create a variable. And to do so, first you go up
here to the top under Edit, and you go to define variables. So let's say we want
to build a variable. I'm going to click on Create. I'm going to give it a name. I'm going to call it "count." And the data type is important. It's set to logic here, but
we want it to hold a number. It could hold text, it
could hold a true or false, but in this case I
want to hold a number. OK So now, I just have
that variable set up, but I still haven't configured
any of these blocks. So let's click on the first
one, which is our constant. It's still set up, the
data type is logic, so I'm going to
switch it to a number. And by default, it's
holding a value 0. And remember, we want to give
our constant block the number 1. So now this block will always
just provide the number 1 whenever you need it. Now, the variable
block is setup such that first you
click on it, and now that variable we
just created, you'll see it down here in the list. I see counter type, number. Great. And now every time
I have an action, I can either read
or write to it. So remember, here
we're reading from it, so I'm going to
select it to read. And the math block
is set to addition. Good. So let's do the first step. Let's wire the
constant into A or B. It doesn't matter if
they were in A or B. They are both just inputs. So now, we have a and b
going into our math block, and the result is down here. It's this little pound
sign-- it's called result-- and we want to put
it into our variable. So first I'm going to click
on this variable block-- and this is also
the important step that might confuse
you-- is I can assign this to be our counter as well. So our variable is here,
and it's also here, and it could also be a
mile down in our program when we need it later. It's not one block, it
is one memory location that you can call up by
bringing this block wherever you need it. I could have the
value down here. So I know that's a
little subtle step there, but you'll get
comfortable with that. And so now this
variable block counter, we want to write
to it at the end. Because you remember,
we take the value and we put it back
into our variable. And now when I
select it to write, you'll see there's a little
port here now, an input port. I can take the result
of the math block, put it in this
counter, and there is our counter's complete. Every time the sound sensor
detects a sound level above 50, it will execute this
little path here, which will take 1,
the value in counter, add them together, and
put it back in counter. So if this ran 5
times, at the end the counter variable would
be holding the value 5. And let's say we were
somewhere else in our program. This is the first
phase of our program. Let's say our robot
is scanning the room and counting every time
it sees a light or a clap. I can use that value later, so
I could put the variable block over here and select
counter number. And now this counter
block will hold the count after this is executed. So that's a quick
introduction account, and it kind of introduced
variables and constant blocks to you. So good luck with that.