Sensors and Conditionals

So far in our coding puzzles, our programs have really only been able to do a single task, such as move to a point or print some information. Reusing our previous recipe analogy, recipes might give different instructions based on some initial information (If using the optional basil, add it to the soup now for best flavour). We have a similar tool in our toolbox when writing Python programs: Conditionals.

IF

1
2
3
4
5
6
7
8
9

# Give me a number
x = int(input("Your number: "))

# Is x less than 10?
if x < 10:
    # It is! (Notice I'm *indented*)
    print("That is a pretty small number")

print(f"Your number was {x}.")

1
2
3
4
5
6
7
8

### Output ###
First run
>>> Your number: 11
>>> Your number was 11.
Second run
>>> Your number: 3
>>> That is a pretty small number
>>> Your number was 3.

The example above showcases the first of these conditionals. The if keyword is followed by an expression, the character :, and then a block of code that is indented with a tab (Indented just means you’ve got some empty space before the line). The indented block will only be run if the expression after the if keyword is true. So if x=3, then both prints would be run. And if x = 11, only the second print would be run because it is not indented.

While what x < 10 does is rather obvious, Python can evaluate many other expressions, such as the following:

• x >= 10: Greater than or equal to (Written as > =).
• x == 10: Exactly equal to (Note the two =s, to make this expression different from setting variables (x = 10)).
• x < "abc": If x is a string, then is true if x is lexically smaller.
• 0 < x <= 10: x is larger than 0 but less than or equal to 10.

1
2
3
4
5
6
7
8
9
10
11
12

x = int(input("How old are you: "))

under_10 = x <= 10
over_18 = x >= 18

# This doesn't change the previous data
x = 20000

if over_18:
    print("You're quite the old student!")
if under_10:
    print("You're quite the young student!")

Colour and Ultrasonic Sensors

So far, you’ve just been running different code based on the input you supply. So let’s make this a bit more exciting and instead use the values of robot sensors in our conditionals.

Place a colour sensor, and set the port to in1. Next, place an ultrasonic sensor, and set the port to in2.

Now, as we did with the motors, we can integrate these devices into our programs.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

from ev3sim.code_helpers import wait_for_tick
from ev3dev2.sensor import INPUT_1, INPUT_2
from ev3dev2.sensor.lego import ColorSensor, UltrasonicSensor

color = ColorSensor(INPUT_1)
ultrasonic = UltrasonicSensor(INPUT_2)

# Important!
wait_for_tick()

r, g, b = color.rgb
dist = ultrasonic.distance_centimeters

print(f"This colour sensor is reading Red:{r} Green:{g} Blue:{b}.")
print(f"This ultrasonic sensor thinks we are {dist}cm apart.")

Just like motors, we import the code we need (from ev3dev2...), initialise each device to a variable (ultrasonic = UltrasonicSensor(INPUT_2)), which we can use for commands and readings (dist = ultrasonic.distance_centimeters).

Each of these sensors really only has one data point of use, as shown in the example above:

• color.rgb gives 3 values, the red, green and blue components in the colour it currently sees. You can save these values to three different variables using commas, as the example code does.
• ultrasonic.distance_centimeters gives a single value, the estimated distance to the nearest object, measured in centimetres.

ELSE

That’s not the only tool we have however. Often you want to also do something if the expression is false:

1
2
3
4
5
6
7
8

# Give me a number
x = int(input("Your number: "))

if x < 10:
    print("That is a pretty small number")
else:
    print("That is a respectably sized number")
print(f"Your number was {x}.")

1
2
3
4
5
6
7
8
9

### Output ###
First run
>>> Your number: 32
>>> That is a respectably sized number
>>> Your number was 32.
Second run
>>> Your number: 7
>>> That is a pretty small number
>>> Your number was 7.

The rules for this keyword are very similar. After the first indented block, you can add the else keyword, the character :, and then another indented block. This block then only gets run when the first statement is not true (aka false!).

IF IF IF

Not only do we have these tools, but because the indented blocks are just snippets of code, we can add more if statements in the blocks and indent further to check multiple expressions:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

password = "open sesame"

treasure = "Here is your treasure!"

attempt1 = input("What's the password? ")
if attempt1 == password:
    print(treasure)
else:
    print("Try again!")
    attempt2 = input("What's the password? ")
    if attempt2 == password:
        print(treasure)
    else:
        print("You fail! This program will self destruct in 5, 4, 3 ...")

ELIF

Moving our code to the right (indenting) everytime we nest conditionals can be a bit annoying though. For this we have yet another tool:

1
2
3
4
5
6
7
8
9
10
11
12

# Give me a number
x = int(input("Your number: "))

if x < 10:
    print("That is a pretty small number")
elif x <= 20:
    print("That is a respectably sized number")
elif x <= 30:
    print("Getting bigger")
else:
    print("That number is truly massive")
print(f"Your number was {x}.")

1
2
3
4
5
6
7
8
9

### Output ###
First run
>>> Your number: 32
>>> That number is truly massive
>>> Your number was 32.
Second run
>>> Your number: 25
>>> Getting bigger
>>> Your number was 25.

The elif keyword (Shortening of else then if) can be placed after the indented block of an if statement or another elif statement. The indented block after an elif keyword is run only if the expression after the elif keyword is True, and all other previous expressions (in the elif or if statements above) are false. Note that this only checks up until the first if statement it spots:

1
2
3
4
5
6
7
8
9
10
11
12
13

# Give me a number
x = int(input("Your number: "))

if True:
    print("I get printed!")
if x < 10:
    print("I get printed if x < 10")
elif x == 32:
    # Only checks up to x < 10
    print("I get printed if x == 32")
elif x == 32:
    # If x==32, then the first `elif` is executed, not me :(
    print("I don't :(")

1
2
3
4
5
6
7
8
9

### Output ###
First run
>>> Your number: 3
>>> I get printed!
>>> I get printed if x < 10
Second run
>>> Your number: 32
>>> I get printed!
>>> I get printed if x == 32

AND OR NOT?

One last tool in our toolbox is the terms and, or and not. These give us a way to combine or modify expressions to make code easier to read.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

expression_1 = False
expression_2 = True

### TOOL 1: The `and` keyword.

# Long way
if expression_1:
    if expression_2:
        # I only get run if both are true.
        print("AND!")

# Is the same as
if expression_1 and expression_2:
    print("AND!")

### TOOL 2: The `or` keyword.

# Long way
correct = False
if expression_1:
    correct = True
if expression_2:
    correct = True
if correct:
    # I only get run if either (or both) are true.
    print("OR!")

# Is the same as
if expression_1 or expression_2:
    print("OR!")

### TOOL 3: The `not` keyword.

# Long way
if expression_1:
    pass # do nothing
else:
    print("NOT!")

# Is the same as
if not expression_1:
    print("NOT!")

1
2
3
4
5

### Output ###
>>> OR!
>>> OR!
>>> NOT!
>>> NOT!