2017 Botball WorkshopSlides-V2017.01.16

Welcome to Botball 2017!
Before we get started

1.
2.
3.
Sign in, and collect your materials and electronics.

KIPR staff may come around and install files as needed.
Charge your Wallaby batteries-WHITE to WHITE (refer to next slide)
KIPR Robotics
Controller - Wallaby
1.
Open the 2017 Parts List folder, which contains files that list
all of your Botball robot kit components. Please go through the
lists and verify that you have received everything.
Build the DemoBot.
2.
Raise your hand if you need help or have questions.

Page
:1
Professional Development Workshop

1993 2017 KIPR
Charging the Controllers Battery
For charging the controllers battery, use only the power

supply which came with your controller.
It is possible to damage the battery

by using the wrong charger or
excessive discharge!
The standard power pack is a lithium iron

(LiFe) battery, a safer alternative to lithium polymer
batteries. The safety rules applicable for recharging any
battery still apply:
Do NOT leave the battery unattended while charging.

Charge in a cool, open area away from flammable materials.
Page
:2

1993 2017 KIPR
KRC Wallaby Controller Guide

Color Touch Screen
KIPR Robotics Controller

Wallaby
2 Servo
Motor Ports 2 Motor Ports
(Port # 0 & 1) (Port # 0 & 1)
Page
:3
Download port
(micro USB)
USB
Micro HDMI
Power (external battery
connection)
6 Analog
Sensor Ports
(Port # 0 - 5)
2 Servo
2 Motor Ports Motor Ports
10 Digital
Sensor Ports (Port # 2 & 3) (Port # 2 & 3)
(Port # 0 - 9)
1993 2017 KIPR
Power Switch
Making the Connection
All connections are as follows:

Yellow to Yellow (battery to controller)
White small to White small (charger to battery)
Black to Black (motors, servos, sensors)
Page
:4

1993 2017 KIPR
Wallaby Power
The KIPR Robotics Controller Wallaby, uses an external battery

pack for power.
Page
It will void your warranty to use a battery pack with the Wallaby that hasnt
been approved by KIPR.
Make sure to follow the shutdown instruction on the next slide.

Failure to do so will drain your battery to the point where it can no
longer be charged. If you plug your battery into the charger and the
blue lights continue to flash then you have probably drained your
battery to the point where it cannot be charged again. You can
purchase a replacement battery from www.botballstore.org.
:5

1993 2017 KIPR
Wallaby Power Down
From the Software Suite select Shutdown

Select Yes
From the Wallaby Home Screen press Shutdown

Select Yes
Go to your Wallaby screen and check to see if it is

halted
Slide the power switch to off AND unplug the

battery, using the yellow connectors, being careful
not to pull on the wires
Page
:6

1993 2017 KIPR
Build the DemoBots

Build your robot using the DemoBot Building Guide
(Found on the team Homebase under 2017 team
resources)
Page
:7

1993 2017 KIPR
Hi! Im Botguy, the Botball mascot!
Botball 2017
Prepared by the KISS Institute for Practical Robotics (KIPR)
with significant contributions from KIPR staff
and the Botball Instructors Summit participants
v2017.01.06-2
Page
:8

1993 2017 KIPR
Thank you for participating!

We couldnt do it without you!
KIPRs mission is to:
Page
improve the publics understanding of science, technology, engineering, and math;

develop the skills, character, and aspirations of students; and
contribute to the enrichment of our school systems, communities, and the nation.
:9

1993 2017 KIPR
Housekeeping
Introductions: workshop staff and volunteers

Food: lunch is on your own
Workshop schedule: 2 days
Page
: 10

1993 2017 KIPR
Workshop Schedule
Day 1
Page
Day 2
Botball Overview
Getting started with the KIPR Software Suite
Explaining the Hello, World! C Program
Designing Your Own Program
Moving the DemoBot with Motors
Fun with Functions
Moving the DemoBot Servos
Repetition, Repetition: Counting
Making Smarter Robots with Sensors
Repetition, Repetition: Reacting
Botball Game Review

Motor Position Counter
Measuring Distance
Color Camera
Moving the iRobot Create: Part 1
iRobot Create Sensors
Logical Operators
Resources and Support
Making a Choice
Line-following
Homework
: 11

1993 2017 KIPR
Thanks to our national sponsors!
Page
: 12

1993 2017 KIPR
Thanks to our regional sponsors!
Page
: 13

1993 2017 KIPR
Thanks to our regional hosts!
Page
: 14

1993 2017 KIPR
Botball Overview
What and when?
GCER and ECER
Preview of this years game
Homework for tonight
Page
: 15

1993 2017 KIPR
What is Botball?
Produced by the KISS Institute for Practical Robotics (KIPR), a

non-profit organization based in Norman, OK.
Engages middle and high school aged students in a team-oriented

robotics competition based on national education standards.
By designing, building, programming, and documenting robots,

students use science, technology, engineering, math, and writing
skills in a hands-on project that reinforces their learning.
Page
: 16

1993 2017 KIPR
When is Botball?
2016
FALL
Jan. Mar.
Prof. Dev. workshops.
Recruit teams.
Fundraise.
Apply for scholarships.
Page
: 17
7 9 Weeks
Mar. Jun.
July
2017
Regional tournaments.
Design, build, & program

autonomous robots.
Document process online.

1993 2017 KIPR
Global Conference on
Educational Robotics.
International Botball.
When is Botball?
FALL
2016
Jan. Mar.
Recruit teams.
Fundraise.
7 9 Weeks
Mar. Jun.
July
2017

autonomous robots.
YOU ARE HERE!
Provides the skills and tools necessary to compete in the tournament.

Teams will learn to program robots, and will leave with working systems.
Skills and tools/equipment are kept and are reusable outside of Botball.
Not a standalone curriculum! Goal is to support team success in Botball!

(For building and programming resources, visit the Team Home Base.)
Page
: 18

1993 2017 KIPR
When is Botball?
FALL
2016
Jan. Mar.
Recruit teams.
Fundraise.
Page
7 9 Weeks
Mar. Jun.
July
2017

autonomous robots.
Reinforces computational thinking and the engineering design process.
Teams must submit three online project documents, which count for points.
Online support throughout the season from KIPR and other Botball teams.
: 19

1993 2017 KIPR
When is Botball?
FALL
2016
Jan. Mar.
Recruit teams.
Fundraise.
Page
7 9 Weeks
Mar. Jun.
July
2017

autonomous robots.
Practice: teams test and calibrate robot entries on the official game boards
Seeding rounds: teams compete against the task to score the most points
Double elimination (DE) rounds: teams compete head-to-head
Alliance matches: teams eliminated in DE pair up to score points together
Onsite documentation: 8-minute technical presentation to judges
: 20

1993 2017 KIPR
When is Botball?
FALL
2016
Jan. Mar.
Recruit teams.
Fundraise.
7 9 Weeks
Mar. Jun.
July

autonomous robots.
Global Conference on Educational Robotics (GCER)
International Botball Tournament: all teams are invited to participate

Paper presentations: students may submit and present papers at GCER
Guest speakers: presentations from academic and industry leaders
Autonomous showcase: students display projects in a science fair style
YOU ARE ALL ELIGIBLE!

Page
: 21
2017

1993 2017 KIPR
GCER-2017
Global Conference on Educational Robotics
Norman, Oklahoma
July 8-12, 2017
International Botball Tournament
Autonomous Robotics Showcase
Meet and network with students from
around the country and world
Talks by internationally recognized
robotics experts
Teacher, student, and peer reviewed
track sessions
http://gcer.net
Page
: 22

1993 2017 KIPR
GCER-2017
Global Conference on Educational Robotics
Preconference classes on July 7th
International Junior Botball Challenge
KIPR Open Autonomous Robotics Game
Botball for grown-up kids!
Autonomous
Aerial
Vehicle
Competition
Page
: 23

1993 2017 KIPR
ECER-2017
European Conference on Educational Robotics
Sofia Tech Park
Sofia, Bulgaria
April 24-28, 2017
Page
: 24
European Botball Competition

Talks by Researchers and Students

1993 2017 KIPR
Botball game board
Page
: 25

1993 2017 KIPR
Homework for tonight
Review the game rules on your Team Home Base
We will have a 30-minute Q&A session tomorrow.
After the workshop, ask questions about game rules in

the Game Rules Forum.
You should regularly visit this forum.

You will find answers to the game questions there.
Page
: 26

1993 2017 KIPR
Botball Team Home Base

Found at http://homebase.kipr.org
Page
: 27

1993 2017 KIPR
Preview of this years Botball game

Robots Assisting a Modern Agricultural Operation
Managing a modern agricultural operation is hard work,
but with the use of robotic technologies, the operations can
become more efficient in their cultivation and use of
resources, in particular water and fertilizer. It is planting
time and Agrobot has just finished getting the family farm
ready.
Hold your questions!

Game Q&A is tomorrow!
Page
: 28

1993 2017 KIPR
Getting Started with the KIPR Software Suite

What is a programming language?
How can I create new projects and files?
How can I write and compile source code?
How can I run programs on the KIPR Wallaby?
Page
: 29

1993 2017 KIPR

Human
Blah! Blah!
Blah! Blah!
??
?
Computer
Computers only understand machine language (stream of bytes),

which computers can read and execute (run).
Unfortunately, humans dont speak machine language
Page
: 30

1993 2017 KIPR

Compiler
Human
Programming
Language
Computer
Machine
Language
Translates
Humans have created programming languages that allow them (humans) to

write source code that is easier for them (humans) to understand.
Source code is compiled (translated) by a compiler (part of the KIPR Software

Suite) into machine language so that the computer can read and execute (run)
the code.
Programming languages have funny names (C, C++, Java, Python, )
Page
: 31

1993 2017 KIPR
Connect the Wallaby to your computer

at Workshop and Tournament
Connect the Wallaby to your computer using USB Cable

1.
2.
Plug battery into Wallaby- YELLOW TO YELLOW.

Turn on the Wallaby with the black switch on the side
1 Put micro
USB end here
1.
2.
Page
: 32
2 Attach
USB to
computer
Once your Wallaby has booted, the Wallaby will appear in the list of
available Ethernet connections for your computer.
If you get a message about the driver raise your hand for help or go to the
team home base- Troubleshooting- USB driver for instructions
1993 2017 KIPR
Loading the Starting Web Page (USB)

1. Launch your web browser (such as Chrome or Firefox)
and power up your Wallaby.
2. Copy this IP address into your browsers address bar
followed by : and port number 8888; e.g.,
192.168.124.1:8888
IP address
Port #
3. Note that USB cable IP address is 192.168.124.1:8888

4. The user interface for the package will now come up in
your browser.
Page
: 33

1993 2017 KIPR
Connect the Wallaby to your computer,

Smart Phone or Tablet At School
Page
Connect the Wallaby to your Browser device via Wi-Fi

This is great at home or School
Not recommended at Large Workshops or any Tournament
1.
Turn on the Wallaby with the black switch on the side
1.
Use the info (Wallaby # and Pass Word) in the about page to connect via Wi-Fi
: 34

1993 2017 KIPR
Connection
When you are connected to your Wallaby,
your device may give various errors; no
internet connection or connected with
limited..
In the bottom right corner of the KIPR IDE
there is an icon that shows if you are still
connected to the Wallaby.
connected
Page
: 35

1993 2017 KIPR
NOT
connected
Loading the Starting Web Page (Wi-Fi)

1. Launch a web browser such as Chrome or Firefox and
power up your Wallaby. Note that Internet Explorer
will not work. Connect to the Wallaby via Wi-Fi.
2. Copy this IP address into your browsers address bar
followed by : and port number 8888; e.g.,
192.168.125.1:8888
IP address
Port #
4. The user interface for the package will now come up in

your browser.
5. You may use a computer, tablet or even a smart phone
through Wi-Fi.
Page
: 36

1993 2017 KIPR
How can I write and compile

my own source code?
To make it easier for you to
learn and use a programming
language, KIPR provides a
web-based Software Suite
which will allow you to write
and compile source code using
the C programming language.
The development package will
work with almost any web
browser except Internet
Explorer.
Page
: 37

1993 2017 KIPR
Creating your first project

1. Click on the KISS IDE button.
NOTE: The buttons might be in different locations depending on device type.
Page
: 38

1993 2017 KIPR
Creating your first user folder

1.
2.
Add a new user folder by clicking the + sign in

the Project Explorer.
Name your new user folder by the students
name to help organization. All of your
different projects will go into this user folder.
Student Name
3.
Page
: 39

1993 2017 KIPR
Click Create to complete.
Creating your first project

1.
2.
Page
: 40
Go back to Project Explorer and select the User

Name you created from the drop down. This is
the folder you created.
Click +Add Project. You are adding a project to
your folder.

1993 2017 KIPR
Name your project

1. Give your project a descriptive name
Note: you will have a lot of students projects, so consider using their first
name followed by the name of the activity.
2. Give a descriptive Source File Name as well. The Source File

needs to end with a .c
Page
: 41
Then press the Create button.

1993 2017 KIPR
Compile and Then Run Your Project

1. Click the Compile button for your project and, if successful, click
Run so you can run your project to see if it works.
NOTE: When you compile, your project is automatically saved.
Page
: 42

1993 2017 KIPR
Starting another project

Note: one project = one program.
Click the + Add Project button or click the Menu button to return
to the starting menu.
Proceed as before.
The Project Explorer panel will show you all of the user folder
projects and actively edited files.
Page
: 43

1993 2017 KIPR

Program flow and the main function
Programming statements and functions
Comments
Page
: 44

1993 2017 KIPR
Hello, World!
Note: We will use this template

every time; we will delete lines
we dont want, and we will
add lines that we do want.
Page
: 45

1993 2017 KIPR
Program flow and line numbers
Begin
Top
Print Hello, World!
Return 0.
End
Bottom
Computers read a program just like you read a book

they read each line starting at the top and go to the bottom.
Computers read incredibly quickly
approximately 800-million lines per second!
Page
: 46

1993 2017 KIPR
Source code
This is the source code for our first C program.

Lets look at each part of the source code.
Page
: 47

1993 2017 KIPR
The main function

A function defines a list of actions to take.
A function is like a recipe for baking a cake.
When you call (use) the function,
the program follows the instructions and bakes the cake.
// Created on Thu January 10 2017
int main()
{
printf("Hello, World!\n");
return 0;
}
This is the main() function.
When you run your program,

the main function is executed.
A C program must have
exactly one main() function.
Page
: 48

1993 2017 KIPR
Block of code
The list of actions that the function takes is defined inside a block of
code.
Begin
End
int main()
Block Header
{
return 0;
}
A block is defined between a

beginning curly brace { and an
ending curly brace }.
Page
: 49

1993 2017 KIPR
This is a block of code.
A block of code should

always be preceded by
a block header, which is
the line just above the {.
Programming statements

int main()
{
Statement #1 printf("Hello, World!\n");
Statement #2 return 0;
}
Inside the block of code

(between the { and } braces),
we write lines of code called
programming statements.
Each programming statement
is an action to be executed by
the computer (or robot)
in the order that it is listed.
There can be any number of
programming statements
within a block of code.
Page
: 50

1993 2017 KIPR
Ending a programming statement

int main()
{
return 0;
}
Each programming statement

ends with a semicolon ;
(unless it is followed by a new
block of code).
This is similar to an English sentence, which ends with a period.

If an English statement is missing a period, then it is a run-on sentence.
Page
: 51

1993 2017 KIPR
Ending the main function

int main()
{
return 0;
}
The return statement is the

last line before the } brace.
Page
: 52

1993 2017 KIPR
The main function ends with a

return statement, which is a
response or answer to the
computer (or robot).
In this case, the answer back

to the computer is 0.
Comments
The green text at the top of the program is called a comment.

int main()
{
return 0;
}
Page
: 53

1993 2017 KIPR
Comments are helpful notes

that can be read by you or
your teamthey are ignored
(not read) by the computer!
Text color highlighting

The KISS IDE highlights parts of a program to make it easier to read.
(By default, the KISS IDE colors your code and adds line numbers.)
Includes in purple
Comments in green
Text strings appear in red
Keywords appear in blue
Page
: 54
// Commenting for the flow of code

1993 2017 KIPR
Print your name

Description: Write a program for the KIPR Wallaby that prints your name.
Solution:
Source Code
Flowchart
START
int main()
{
// 1. Print your name.
printf("Botguy\n");
// 2. End the program.
return 0;
Page
: 55
Print your name.

Return 0.
STOP

1993 2017 KIPR

Breaking down a task
Pseudocode, flowcharts, and comments
wait_for_milliseconds function
Debugging your program
Page
: 56

1993 2017 KIPR
Complex tasks simple subtasks
Break down the objectives (complex tasks) into smaller objectives

(simple subtasks).
Break down the smaller tasks into even smaller tasks.

Continue this process until each subtask can be accomplished by a
list of individual programming statements.
For example, the larger task might be to make a PB&J Sandwich

which has smaller tasks of getting the bread and PB&J ready and
then combining them.
Page
: 57

1993 2017 KIPR
Practice printing
Description: Write a program for the KIPR Wallaby that prints "Hello,
World! on one line, and then prints your name on the next line.
Analysis: What is the program supposed to do?
Flowchart
Begin
Pseudocode
Comments
1.
2.
3.
// 1. Print Hello, World!
Print Hello, World!

Print your name.
End the program.
Print Hello, World!

Print your name.

Return 0.
In English,
write a list of actions
to solve an activity.
Page
: 58
These are three different

ways to do this.
1993 2017 KIPR
End
Practice printing
Solution: Create a new project, create a new file, and enter your
pseudocode (as comments) and source code in the main function.
Note: remember to give your project and file descriptive (unique) names!
Source Code
int main()
{
Pseudocode (Comments)
int main()
{
}
Helps you write

the real code!

printf("Botguy\n");
return 0;
}
Execution: Compile and run your program on the KIPR Wallaby.

Page
: 59

1993 2017 KIPR
Practice printing
Reflection: What did you notice after you ran the program?
The Wallaby reads code and goes to the next line faster than a blink of your eye.
At 800MHz, the Wallaby is executing millions of lines of code per second!
To control a robot, sometimes it is helpful to wait for some duration of time

after a function has been called so that it can actually run on the robot.
To do this, we use the built-in function called wait_for_milliseconds(),

later this can be shortened to msleep()
Lets use this!

Page
: 60

1993 2017 KIPR
Using wait_for_milliseconds
int main()
{
printf("slow ");
wait_for_milliseconds(2500);
printf("printer\n");
return 0;
}
// wait for 2500 ms
What is this?
Another name for wait_for_milliseconds() is msleep().
It is identical and shorter to type, but more difficult to remember.
msleep(2500) is the same as wait_for_milliseconds(2500).
Page
: 61

1993 2017 KIPR
Waiting for some time

Description: Write a program for the KIPR Wallaby that prints "Hello,
World! on one line, waits two seconds, and then prints your name
on the next line.
Flowchart

Pseudocode
Comments
1.
2.
3.
4.
Print Hello, World!

Wait for 2 seconds.
Print your name.
End the program.
Begin
Print Hello, World!
Wait for 2 seconds.
// 2. Wait for 2 seconds.

Print your name.

Return 0.
New!
Page
: 62

1993 2017 KIPR
End

Note: remember to give your project and file descriptive (unique) names!
Source Code
int main()
{
}
int main()
{
printf("Botguy\n");
return 0;

Page
: 63

1993 2017 KIPR

Did your code work the first time you typed it in?
Did you have any errors?
Page
: 64

1993 2017 KIPR
Debugging Errors
!!! ERROR !!!
If you do not follow the rules of the programming language, then

the compiler will get confused and not be able to translate your
source code into machine codeit will say Compile Failed!
The Wallaby will try to tell you where it thinks the error is located.
The process of trying to resolve this error is called debugging.
To test this, remove a ; from one of your programs and compile it.
Page
: 65

1993 2017 KIPR
Debugging Errors
line # : col # (the error is on or before the line # 6)
expected ; (semicolon)
When there is an error, you can ignore the first error line
(In function main) and read the next to see what
the first error is. If you have a lot of errors, start fixing
them from the top going down. Fix one or two and
recompile.
Page
: 66

1993 2017 KIPR

Plugging in motors (ports and direction)
motor functions
Page
: 68

1993 2017 KIPR
Check your robots motor ports
To program your robot to move, you need to know

which motor ports your motors are plugged into.
Computer scientists start counting at 0, so the motor

ports are numbered 0, 1, 2, and 3.
Page
: 69

1993 2017 KIPR
Wallaby motor ports

Motor Labels are
on the Case
Motor Ports 0, 1, 2, and 3
Page
: 70

1993 2017 KIPR
Plugging in motors
Motors have red wire and a black wire with a two-prong plug.
The Wallaby has 4 motor ports numbered 0 & 1 on left, and 2 & 3 on right.
When a port is powered (receiving motor commands), it has a light that glows
green for one direction and red for the other direction.
Plug orientation order determines motor direction.
By convention, green is forward (+) and red is reverse ().
Motor Port #2
Motor Port #3
Page
: 71

1993 2017 KIPR
Drive motors have

a two-prong plug.
Plugged in motors
DemoBot Motor Ports 0 (left wheel) and 2 (right wheel)
Page
: 72

1993 2017 KIPR
Motor direction
You want your motors going in the same direction;
otherwise, your robot will go in circles!
Motors have red wire and a black wire with a two-prong plug.
There is no left side or right side.
You can plug these in two different ways:
One direction is clockwise, and the other direction is counterclockwise.

The red and black wires help determine motor direction.
1 2
Page
: 73
2 1

1993 2017 KIPR
Motor port and direction check

There is an easy way to check this!
Manually rotate the tire, and you will see an LED light up by the motor port
(the port # is labeled on the board).
If the LED is green, it is going forward (+).
If the LED is red, it is going reverse ().
Use this trick to check the port #s and direction of your motors.
If one is red and the other is green,
turn one motor plug 180 and plug it back in.
The lights should both be green if the robot is moving forward.
Page
: 74

1993 2017 KIPR
Use the Motor Widget
Page
: 75

1993 2017 KIPR
Common motor functions

Motor port #
(between 0 and 3)
There are several functions for motors.

We will begin with motor.
motor(0, 100);
A positive number should drive
// Turns on motor port #0 at 100% power.
the motor forward; if not,
// Select any power between -100% and 100%. rotate the motor plug 180.
wait_for_milliseconds(# milliseconds);
// Wait for the specified amount of time.
ao();
// Turn off all of the motors.
Page
: 76

1993 2017 KIPR
A negative number should

drive the motor reverse.
If two drive motors are plugged

in in opposite directions from
each other, then the robot will
go in a circle.
Using motor and ao
int main()
{
motor(0, 100);
ao();
return 0;
}
Page
: 77

1993 2017 KIPR
KIPR Wallaby functions cheat sheet

Until you are familiar with the functions that you will be using,
use this cheat sheet as an easy reference.
Copying and pasting your own code is also very helpful.
printf("text\n");
wait_for_milliseconds(# milliseconds);
msleep(# milliseconds);
motor(port #, % velocity);
motor_power(port #, % power);
mav(port #, velocity);
mrp(port #, velocity, position);
ao();
enable_servos();
disable_servos();
set_servo_position(port #, position);
wait_for_light(port #);
wait_for_touch(port #);
analog(port #)
digital(port #)
shut_down_in(time in seconds);
Page
: 78
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
Prints the specified text to the screen

Waits specified number of milliseconds before next line
Another name for wait_for_milliseconds (identical)
Turns on motor with port # at specified % velocity
Turns on motor with specified port # at specified % power
Move motor at specified velocity (# ticks per second)
Move motor to specified relative position (in # ticks)
All off; turns all motor ports off
Turns on servo ports
Turns off servo ports
Moves servo in specified port # to specified position
Waits for light in specified port # before next line
Waits for touch in specified port # before next line
Get a sensor reading from a specified analog port #
Get a sensor reading from a specified digital port #
Shuts down all motors after specified # of seconds

1993 2017 KIPR
Wallaby Library Documentation

Access the Wallaby documentation by selecting the Help button in the KISS IDE
Page
: 79

1993 2017 KIPR
Moving the DemoBot

Description: Write a program for the KIPR Wallaby that drives the
DemoBot forward at 80% power for two seconds, and then stops.
Flowchart
Begin
Pseudocode
1.
2.
3.
4.
Comments
Drive forward at 80%. //

Wait for 2 seconds. //
Stop motors.
//
End the program.
//
1. Drive forward at 80%.

2. Wait for 2 seconds.
Drive forward at 80%.

Wait for 2 seconds.
3. Stop motors.
4. End the program.
Stop motors.
Return 0.
End
Page
: 80

1993 2017 KIPR
Moving the DemoBot

Note: remember to give your project and file descriptive, unique names!
Source Code
Psuedocode (Comments)
int main()
{
// 1. Drive forward at 80%.
// 3. Stop motors.
}
int main()
{
// 1. Drive forward at 80%.
motor(0, 80);
motor(3, 80);
// 3. Stop motors.
ao();
return 0;
}

Page
: 81

1993 2017 KIPR
Moving the DemoBot

Did the DemoBot move forward?

Positive (+) numbers should move the motors in a clockwise direction
(forward); if not, rotate the motor plug 180 where it plugs into the
Wallaby.
If your robot moves in a circle, one motor is either not moving (is it plugged
in?) or they are moving in opposite directions (rotate the motor plug 180).
Did the DemoBot drive straight?
How could you adjust the code to make the robot drive straight?
How can you make the robot drive backwards?
Professional
Development
Workshop
How can you make the robot
turn left
or right?
Page
: 82
1993 2017 KIPR
Robot driving hints

Remember your # line:
positive numbers (+) go forward and negative numbers () go in reverse.
Reverse
Forward
Driving straight: it is surprisingly difficult to drive in a straight line
Problem: Motors are not exactly the same.

And many, many
Problem: The tires might not be aligned perfectly.
other reasons
Problem: One tire has more resistance.
Solution: You can adjust this by slowing down or speeding up the motors.
Making turns:
Page
Solution: Have one wheel go faster or slower than the other.

Solution: Have one wheel move while the other one is stopped.
Solution: Have one wheel move forward and the other wheel move in reverse
(friction is less of a factor when both wheels are moving).
: 83

1993 2017 KIPR
Activity 1 (connections to the game)

You have a paper copy of this activity in your registration packet.
1. Start with DemoBot completely within the starting box on mat A.
2. Recover 4 poms and a yellow foam brick that start out within the
nearest garage or around circle 4 (12-14 away on game board or
FRP).
3. The poms and yellow brick must come to rest completely within
the starting box.
Page
: 84

1993 2017 KIPR
Activity 1 video (possible solution)
Page
: 85

1993 2017 KIPR

Plugging in servos (ports)
enable_servos and disable_servos functions
set_servo_position function
Page
: 86

1993 2017 KIPR
Servos
A servo motor (or servo for short) is a motor that rotates to a specified
position between 0 and 180.
Servos are great for raising an arm or closing a claw to grab something.
Servo motors look very similar to non-servo motors, but there are differences
A servo has three wires (orange, red, and brown) and a black plastic plug.
A non-servo motor has two gray wires and a two-prong plug.
Large servo
Small servo
Page
: 87

1993 2017 KIPR
KIPR Robotics Controller servo ports
Servo Ports 0, 1, 2, and 3
Page
: 88

1993 2017 KIPR
Plugging in Servos
The KIPR Robotics Controller has 4 servo ports numbered 0 (left) & 1 (right) on
the left, and 2 (left) & 3 (right) on the right.
Notice that the case of the KIPR Robotics Controller is marked:
(S) for the orange (signal) wire, which regulates servo position
(+) for the red (power) wire
() for the brown (ground) wire (the ground is down, down is negative)
(S) signal wire
(+) power wire
() ground wire
Servo Port #3
Servo Port #2
Page
: 89

1993 2017 KIPR
Servo positions
Think of a servo like a protractor
Angles in the 180 range of motion (between 0 and 180) are divided into
2048 servo positions.
These 2048 positions range from 0 to 2047, but due to internal mechanical
hard stop variability you should use 150 to 1900
(remember: computer scientists start counting with 0, not 1).
This allows for greater precision when setting a position
(you have 2048 different positions you can choose from instead of just 180).
The default position is 1024

(centered).
1024
150
1900
0
Page
: 90
2047
1993 2017 KIPR
Use the Servo widget
Page
: 91

1993 2017 KIPR
Testing Servos with the Servos screen

Select the
servo port
The current
servo position
Enable
servos
Page
: 92

1993 2017 KIPR
Testing Servos with the Servos screen

Use your finger
to move the dial.
Servo @ 2047
(maxed out)
Servo @ 1513
Do not push a servo beyond its limits

(less than 0 or more than 2047).
This can burn out the servo motor!
Page
: 93

1993 2017 KIPR
Servo @ 537
Servo functions
To help save power, servo ports by default are not active until they are
enabled.
Functions are provided for enabling or disabling all servo ports.
A function is also provided for setting the position of a servo.
enable_servos();
// Activate (turn on) all servo ports.
set_servo_position(2, 925);
disable_servos();
Page
// Rotate servo on port #2 to position 925.
// De-activate (turn off) all servo ports.
Remember: the useable range of positions is from 150 to 1900.

The default position when servos are enabled is 1024 (centered), which means that all
servos will automatically move to this position when enable_servos is called.
You can preset a servo position by calling set_servo_position before calling
enable_servos. This will make the servo move to this position rather than center.
: 94

1993 2017 KIPR
Using servo functions
int main()
{
enable_servos();
disable_servos();
return 0;
}
Page
: 95

1993 2017 KIPR
Using servo functions

What happens when we
set the servo position
before enable_servos?
int main()
{
enable_servos();
disable_servos();
return 0;
}
Page
: 96

1993 2017 KIPR
Wave the servo arm

Description: Write a function for the KIPR Wallaby that waves the
DemoBot servo arm up and down.
Remember to enable the servos at the beginning of your program,

and disable the servos at the end of your program!
Warning: The arm mounted on your DemoBot prevents the servo from freely
rotating to all possible positions (it will run into the KIPR Wallaby controller or
the chassis of the robot)!
Do not keep trying to move a servo to a position it cannot reach, as this can burn out the servo
Page
: 97
and also consume a lot of power from your robot.

Use the Servo screen to determine the limits of the DemoBot arm, write these numbers down,
and then use these numbers in your code.

1993 2017 KIPR
Wave the servo arm

Description: Write a program for the KIPR Wallaby that waves the
DemoBot servo arm up and down. Write a function that does one
wave. Call it from your main function
Pseudocode
Comments
1.
2.
3.
4.
5.
6.
7.
// 1. Enable servos.
Page
Enable servos.
Move servo to YOUR limit.
Wait for 3 seconds.
Move servo to YOUR other limit.
Wait for 3 seconds.
Disable servos.
End the program.
: 98
// 2. Move servo to YOUR limit.

// 4. Move servo to YOUR other limit.
// 6. Disable servos.

1993 2017 KIPR
Wave the servo arm

Analysis:
Flowchart
Begin
Enable servos.
Wait for 3 seconds.

Wait for 3 seconds.
Disable servos.
Return 0.
Page
: 99
Professional Development
Workshop
End
1993 2017 KIPR
Lunch!
Page
: 100

1993 2017 KIPR

1. Start with your DemoBot at least partially within the starting box.
See extension for more practical application.
2. Using a servo controlled claw, recover a blue foam block from
circle 9 on mat A.
3. The blue foam block should be elevated off the surface while
wheel movement occurs and should be placed on the playing
surface inside of the starting box.
Page
: 101

1993 2017 KIPR
Activity 2 Video (possible solution)
Page
: 102

1993 2017 KIPR
Draw a square
DemoBot along a path in the shape of a square.
Page
Start with having the robot make a 90 turn.

Then add in forward movements to have the robot drive along a square path.
Remember the direction your robot is taking.
: 103

1993 2017 KIPR
Draw a square
Flowchart
Begin
Pseudocode
Comments
Drive forward.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
// 1. Drive forward.
Turn right 90
// 2. Turn right 90-degrees.
Drive forward.
Turn right 90
Drive forward.
Turn right 90.
Drive forward.
Turn right 90.
Drive forward.
Turn right 90.
Drive forward.
Turn right 90.
Stop motors.
End the program.
Drive forward.
Turn right 90

Drive forward.
Turn right 90
// 9. Stop motors.
Stop motors.
Return 0.
End
Page
: 104

1993 2017 KIPR
Draw a square
int main()
{
motor(0, 100);
motor(3, 100);
Solution:

motor(0, 100);
motor(3, -100);
Here is some code that uses the motor()

and wait_for_milliseconds() functions
to drive the robot in a square.
Note: this is just one of many solutions.
motor(0, 100);
motor(3, 100);
motor(0, 100);
motor(3, -100);
motor(0, 100);
motor(3, 100);
motor(0, 100);
motor(3, -100);
motor(0, 100);
motor(3, 100);

motor(0, 100);
motor(3, -100);
ao();
// 9. Stop motors.
return 0; // 10. End the program.
} // end main
Page
: 105

1993 2017 KIPR
Fun with Functions

Writing your own functions
Function prototypes, definitions, and calls
Page
: 106

1993 2017 KIPR
Draw a square
Drive forward.
Reflection:
Notice there are many repeated steps.
For example:
// Drive forward.
motor(0, 100);
motor(0, 100);
Turn
right.
Drive forward.
is repeated 4 times in this program!

Also, Turn right 90-degrees.
Turn
right.
Drive forward.
You will quickly learn to use copy-andpaste over and over again, but there is a
better and easier way
Learning to write your own functions
allows you to reuse code easily!
Turn
right.
int main()
{
motor(0, 100);
motor(3, 100);
motor(0, 100);
motor(3, -100);
motor(0, 100);
motor(3, 100);
motor(0, 100);
motor(3, -100);
motor(0, 100);
motor(3, 100);
motor(0, 100);
motor(3, -100);
Drive forward.
motor(0, 100);
motor(3, 100);
Turn
right.

motor(0, 100);
motor(3, -100);
ao();
// 9. Stop motors.
} // end main
Page
: 107

1993 2017 KIPR
Remember: a function is like a recipe.

When you call (use) the function, the computer (or robot) does all
of the actions listed in the recipe in the order they are listed.
Functions are very helpful if you take some actions multiple times:
Page
driving straight forward drive_forward();

making a 90 left turn turn_left_90();
making a 180 turn turn_around();
lifting an arm up lift_arm();
closing a claw close_claw();
We made these up
and thats the point!
You can write your
own functions to do
whatever you want!
Functions often make it easier to (1) read the main function, and
(2) change distance, turning, timing, or other values if necessary.
: 108

1993 2017 KIPR
There are three components to a function:

1.
2.
3.
Page
Function prototype: a promise to the computer that the function is

defined somewhere (an entry in the table of contents of a recipe book)
Function definition: the list of actions to be executed (the recipe)
Function call: using the function (recipe) in your program
void drive_forward();
int main()
{
drive_forward();
return 0;
} // end main
void drive_forward()
// function definition
{
motor(0, 100);
motor(3, 100);
ao();
} // end drive_forward
: 109
// function prototype
// function call

1993 2017 KIPR
void is a data
type, we will
talk about data
types later

Function prototypes
go above main.
Function calls
go inside main
(or inside other
functions).
Function definitions
go below main.
Page
: 110
int main()
{
drive_forward();
return 0;
} // end main
// function call
Use void in your

function prototype if
you are
commanding the
robot to do
something.
{
motor(0, 100);
motor(3, 100);
ao();

1993 2017 KIPR

The function prototype and the function definition look the same except for one thing
prototype
definition
Page
: 111
int main()
{
drive_forward();
return 0;
} // end main
// function call
{
motor(0, 100);
Notice: no semicolon!
motor(3, 100);
(Why not?)
ao();

1993 2017 KIPR

int main()
{
drive_forward();
return 0;
} // end main
The function prototype is a

promise to the computer
// function call
that you will tell the

computer what to do in the
function definition.
{
motor(0, 100);
motor(3, 100);
ao();
Neither the function prototype nor the function definition tell the
computer when to use the function. That is the job of the function call
Page
: 112

1993 2017 KIPR

int main()
{
drive_forward();
return 0;
} // end main
The function call makes the

computer jump down to the
// function call
{
motor(0, 100);
The program then executes
motor(3, 100);
all of the lines of code in the
block of code.
ao();
Page
: 113

1993 2017 KIPR

int main()
{
drive_forward();
return 0;
} // end main
// function call
After the computer executes all of the lines of code in

the function definition, the program jumps back up to
the line of code after the function call and continues.
{
motor(0, 100);
motor(3, 100);
This is the end } of the
ao();
Page
: 114

1993 2017 KIPR

// function prototypes
void turn_right();
int main()
{
drive_forward();
turn_right();
return 0;
} // end main
// drive_forward function call

// turn_right function call
void drive_forward() // drive_forward function definition

{
motor(0, 100);
motor(3, 100);
ao();
Page
: 115
void turn_right()
// turn_right function definition
{
motor(0, 100);
motor(3, -100);
ao();
} // end turn_right Professional Development Workshop
1993 2017 KIPR
Draw a square using functions

DemoBot along a path in the shape of a square using functions.
Page
Hint: modify your old square-drawing program to use your own functions.
Break the task down into common subtasks these become your functions!
: 116

1993 2017 KIPR
Code without your functions
Code with your functions
int main()
{
motor(0, 100);
motor(3, 100);
// Function prototype for

// drive_forward_and_turn_right.
void drive_forward_and_turn_right();

motor(0, 100);
motor(3, -100);
motor(0, 100);
motor(3, 100);
main is shorter and

easier to read.

motor(0, 100);
motor(3, -100);
motor(0, 100);
motor(3, 100);
// Function definition for

void drive_forward_and_turn_right()
{
// Drive forward.
motor(0, 100);
motor(3, 100);

motor(0, 100);
motor(3, -100);
motor(0, 100);
motor(3, 100);
// Turn right 90-degrees.

motor(0, 100);
motor(3, -100);

motor(0, 100);
motor(3, -100);
// Stop motors.
ao();
} // end drive_forward_and_turn_right
ao();
// 9. Stop motors.
} // end main
Page
: 117
// Function definition for main.

int main()
{
// Four function calls for
drive_forward_and_turn_right();
return 0;
} // end main

1993 2017 KIPR
Draw a square
Reflection:
1.
2.
It makes the main function easier to

read and understand, and spotting
mistakes is much easier.
You only have to change a value one
time in the function definition for it
to affect the entire program.
For example, to draw a smaller square,
simply change the
wait_for_milliseconds() value in
your drive_forward_and_turn()
function definition from 4000 to 2000.
// Function prototype for

// Function definition for main.
int main()
{
// Four function calls for
return 0;
} // end main
// Function definition for
{
// Drive forward.
motor(0, 100);
motor(3, 100);
// Turn right 90-degrees.
motor(0, 100);
motor(3, -100);
// Stop motors.
ao();
} // end drive_forward_and_turn_right
Page
: 118

1993 2017 KIPR
Advanced waving the servo arm

Create a function to wave your servo arm.
Comments
void
{
//
//
//
//
//
//
}
Page
: 119
wave()
1.
2.
3.
4.
5.
6.
Enable servos.
Wait for 3 seconds.
Wait for 3 seconds.
Disable servos.

1993 2017 KIPR
Move the Servo using functions

void wave();
Solution:
int main()
{
wave(); // function call
return 0;
} // end main
Comments
void
{
//
//
//
//
//
//
}
wave()
1.
2.
3.
4.
5.
6.
Source Code
Enable servos.
Wait for 3 seconds.
Wait for 3 seconds.
Disable servos.
void wave()
{
enable_servos();
// 2. Move servo to YOUR limit.
// 4. Move servo to YOUR other limit.
Use YOUR
servo limits!
disable_servos();
}

Page
: 120

1993 2017 KIPR
Variables and Functions with Arguments

Data types
Creating and setting a variable
Variable arithmetic
Functions with arguments and return values
Page
: 121

1993 2017 KIPR
Variables
A variable is a named container that stores a type of value

(remember void)
A variable has the following three components:
a. the type of data it stores (holds),
b. the name, and
a
c. the value.
int my_cup;
my_cup = 3;
Think of a variable like a cup with your name on it

my_cup
Page
Use int as your

data type if you want
to store whole
numbers (integers)
: 122

1993 2017 KIPR
Variable names
Each variable is given a unique name so we can identify it
Variable names can be almost anything you would like.

Variable names can contain letters, numbers, and underscores (_).
Variable names cannot begin with a number.
An Example:
// Variable to keep a count of events.
int my_variable;
// variable declaration
my_variable = 0;
// variable initialization
Page
: 123

1993 2017 KIPR
Variables
You can set the value to any integer you choose.
Page
: 124
int my_cup;
my_cup = 3;
int my_cup;
my_cup = 4;
my_cup
my_cup

1993 2017 KIPR
Variables
So how could this be useful?
What if we wanted to add balls to the cup
int my_cup;
my_cup = 3;
my_cup = my_cup + 1; // now my_cup is equal to 4
my_cup
Page
: 125
my_cup

1993 2017 KIPR
Remember This?
When you
call this
function,
how long
will it run
for?
int main()
{
drive_forward();
return 0;
}
// function call
{
motor(0, 100);
motor(3, 100);
ao();
}
What if you dont want it to run for this long each time?
Page
: 126

1993 2017 KIPR
Functions with arguments
Function arguments: values you will set when you call the
function
void drive_forward(int milliseconds);
int main()
{
drive_forward(4000);
return 0;
} // end main
// function call
void drive_forward(int milliseconds)

{
motor(0, 80);
motor(3, 80);
wait_for_milliseconds(milliseconds);
ao();
}
Page
: 127

1993 2017 KIPR

with arguments
int main()
{
return 0;
} // end main
// function call
The value in the function call

sets the value of the argument
void drive_forward(int milliseconds) // function definition

{
which is then used in the
motor(0, 100);
motor(3, 100);
ao();
Page
: 128

1993 2017 KIPR

with arguments
The function prototype and the function definition look the same except for one thing
int main()
{
return 0;
} // end main
// function call
void drive_forward(int milliseconds) // function definition

{
motor(0, 100);
motor(3, 100);
wait_for_milliseconds(milliseconds); Notice: no semicolon!
ao();
(Why not?)
Page
: 129

1993 2017 KIPR

with multiple arguments
void drive_forward(int power, int milliseconds);
int main()
{
drive_forward(80, 4000);
return 0;
}
// function call
The value in the function call

sets the value of the argument
void drive_forward(int power, int milliseconds) // function definition

{
which is then used in the
motor(0, power);
motor(3, power);
ao();
}
Page
: 130

1993 2017 KIPR
Repetition, Repetition, Repetition

Program flow control with loops
while loops for counting
while and Boolean operators
Page
: 131

1993 2017 KIPR

Suppose your task is to wave the robot arm 10 times
Begin
Wave Arm.
Pseudocode
Comments
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
//
1. Wave Arm.
//
2. Wave Arm.
//
3. Wave Arm.
//
4. Wave Arm.
//
5. Wave Arm.
//
6. Wave Arm.
//
7. Wave Arm.
//
8. Wave Arm.
Wave Arm.
//
9. Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
End the program.
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
// 10. Wave Arm.
Wave Arm.

Return 0.
End
Page
: 132

1993 2017 KIPR

Now, suppose your objective is to wave the arm 50 times
or 100 times
or 1,000 times
or 12,345 times
You could copy-and-paste lines of code, but it would take a very long time
There has got to be a better way!
(And there is!)
Page
: 133

1993 2017 KIPR
What if we want to repeat the same block of code many times?
We can do this using a loop, which controls the flow of the

program by repeating a block of code.
Page
: 134

1993 2017 KIPR

Begin
Begin
Wave Arm.
Set counter to 0.
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
VS
NO
Is
counter
< 10?
YES
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
Add 1 to counter.
Wave Arm.
Wave Arm.
Return 0.
Return 0.
End
End
Page
: 135

1993 2017 KIPR

Begin
Wave Arm.
This part of the code

is the loop.
Begin
Set counter to 0.
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
VS
NO
Is
counter
< 10?
YES
Wave Arm.
Wave Arm.
Wave Arm.
Wave Arm.
Add 1 to counter.
Wave Arm.
Wave Arm.
Return 0.
Return 0.
End
End
Page
: 136

1993 2017 KIPR
while loops
The while loop checks to see if a Boolean test is true or false
If the test is true, then the while loop continues to execute the block of code that immediately
follows it.
If the test is false, then the while loop finishes, and the line of code after the block of code is
executed.
int main()
{
// Code before loop ...
while (Boolean test) // Loop
{
// Code to repeat ...
}
// Code after loop ...
return 0;
}
Page
: 137

1993 2017 KIPR
while loops
The while loop checks to see if a Boolean test is true or false
If the test is true, then the while loop continues to execute the block of code that immediately
follows it.
If the test is false, then the while loop finishes, and the line of code after the block of code is
executed.
int main()
{
// Code before loop ...
while (Boolean test)
{
}
Begin
End
// Code after loop ...

return 0;
}
Page
: 138

1993 2017 KIPR
Block Header
(no semicolon!)

The Boolean test in a while loop is asking a question:
Is this statement true or false?
The Boolean test (question) often compares two values to one

another using a Boolean operator, such as:
Page
: 139
==
!=
<
>
<=
>=
Equal to (NOTE: two equal signs, not one which is an assignment!)

Not equal to
Less than
Greater than
Less than or equal to
Greater than or equal to

1993 2017 KIPR
Boolean operators cheat sheet
Page
Boolean
English Question
True Example
False Example
A == B
Is A equal to B?
5 == 5
5 == 4
A != B
Is A not equal to B?
5 != 4
5 != 5
A < B
Is A less than B?
4 < 5
5 < 4
A > B
Is A greater than B?
5 > 4
4 > 5
A <= B
Is A less than or equal to B?
4 <= 5
5 <= 5
6 <= 5
A >= B
Is A greater than or equal to B?
5 >= 4
5 >= 5
5 >= 6
: 140

1993 2017 KIPR
Draw a square using a loop

DemoBot along a path in the shape of a square using loops.
Hint: modify your old square-drawing program to use a while loop.

Bonus: use a while loop and functions!

Pseudocode
1.
2.
3.
4.
Page
Set Variable side_counter to 0.

Loop: Is side_counter < 4?
1. Drive forward.
2. Turn right 90.
3. Add 1 to side_counter.
Stop motors.
End the program.
: 141
Comments
// 1. Set Variable side_counter to 0.
// 2. Loop: Is side_counter < 4?

//
2.1. Drive forward.
//
2.2. Turn right 90-degrees.
//
2.3. Add 1 to side_counter.
// 3. Stop motors.

1993 2017 KIPR

Analysis: Flowchart
Begin
Set side_counter to 0.
Boolean Test
YES
NO
Drive forward.
Turn right 90.
Add 1 to side_counter.
Stop motors.
Return 0.
End
Page
: 142

1993 2017 KIPR
Boolean Test
side_counter is < 4?

Solution:
Source Code
int main()
{
int side_counter = 0; // declare and
//initialize variable all in one line
Comments
int main()
{
// 1. Set side_counter to 4.
//
2.1. Drive forward.
//
//
// 3. Stop motors.
}
while (side_counter < 4)

{
motor(0, 100);
motor(3, 100);
wait_for_milliseconds(4000); // forward
motor(0, 100);
motor(3, -100);
wait_for_milliseconds(1500); //right turn
side_counter = side_counter + 1;
}
ao();
return 0;
}
Page
: 143

1993 2017 KIPR

Solution: Use a function!
int main()
{
int side_counter = 0 ;
// loop exits when side counter = 4
while (side_counter < 4)
{
Comments
int main()
{
// 1. Set side_counter to 4.
//
2.1. Drive forward.
//
//
// 3. Stop motors.
}
side_counter = side_counter + 1;
}
ao();
return 0;
}
{
motor(0, 100);
motor(3, 100);
motor(0, 100);
motor(3, -100);
ao();
}
Page
: 144

1993 2017 KIPR
Move the servo arm using a loop

Description: Write a program for the KIPR Wallaby that moves the DemoBot
servo arm from position 200 to 1800 in increments of 100.
Remember to enable the servos at the beginning of your program, and disable the
servos at the end of your program!

Pseudocode
1.
2.
3.
4.
5.
6.
Page
Comments
Set counter to 200.

Set servo position to counter.
Enable servos.
Loop: Is counter < 1800?
1. Wait for 100 milliseconds.
2. Add 100 to counter.
// 1. Set counter to 200

// 2. Set servo position to counter
// 4. Loop: Is counter < 1800?
//
4.1. Wait for 100 milliseconds.
//
4.2. Add 100 to servo position.
3. Set servo position to counter.
//
4.3 Set servo position to counter.
Disable servos.
End the program.
: 145

1993 2017 KIPR

Analysis: Flowchart
Begin
Set counter to 200.

Enable servos.
Is counter <
1800
NO
YES
Wait for 100 milliseconds.

Add 100 to counter.

Disable servos.
Return 0.
Page
: 146

End
1993 2017 KIPR

Source Code
Solution:
int main()
{
int counter = 200;
set_servo_position(0, counter);
Comments
enable_servos();
int main()
{
// 1. Set counter to 200.
// 2. Set servo position to counter.
//
4.1. Wait for 0.1 seconds.
//
4.2. Add 100 to counter.
//
4.3. Set servo position to counter.
}
// Is counter < 1800?

while (counter < 1800)
{
// Add 100 to counter
counter = counter + 100;
// Set servo position to counter
set_servo_position(0, counter);
}
// Disable servos.
disable_servos();
return 0;
Page
: 147
}
1993 2017 KIPR

Analog and digital sensors
Light and touch sensors
wait_for_light() and wait_for_touch() functions
Page
: 148

1993 2017 KIPR
Sensors
You might have realized how difficult it is to be

consistent with just driving blind.
By adding sensors to our robots, we can allow them to

detect things in their environment and make decisions
about them!
Robot sensors are like human senses!

What senses does a human have?
What sensors should a robot have?
Page
: 149

1993 2017 KIPR
Analog and digital sensors

Analog Sensors
Digital Sensors
Range of values:
0 4095
analog(port #)
Sensors:
Page
0 (not pressed) or 1 (pressed)
Ports: 0 5
Function:
: 150
Range of values:
Light
Small reflectance
Large reflectance
Ports: 0 9
Function:
digital(port #)
Sensors:
Large touch
Small touch
Lever touch
Slide sensor

1993 2017 KIPR
KIPR Robotics Controller sensor ports
Sensor Plug
Orientation
Digital Sensor
Ports # 0 9
Page
: 151
Analog Sensor
Ports # 0-5

1993 2017 KIPR
Built-In Digital Sensor: Buttons

The Wallaby has built-in buttons on the right side (opposite
the power switch)
right_button()
left_button()
Page
: 152
returns a value of 1 if the button is being pressed

returns a value of 0 if the button is not being pressed at that time

1993 2017 KIPR
While loop on R button
int main()
{
// Has R button been touched?
while(
)
{
printf(Press the R Button!\n");
}
printf("Ahh! Something touched my Button!\n");

return 0;
}
Page
: 153

1993 2017 KIPR
R button
Sensor waiting functions
wait_for_light(3);
// Waits for the light on port #3 before going to the next line.
wait_for_touch(8);
// Waits for the touch on port #8 before going to the next line.
Page
: 154

1993 2017 KIPR
Using wait_for_light
What is this?
int main()
{
wait_for_light(0);
printf("I see the light!\n");
return 0;
}
Page
: 155

1993 2017 KIPR
Starting your programs with a light
The light sensor is used to start Botball robots at the beginning of

the game, and it is a cool way to automatically start your robot.
The wait_for_light() function allows your program to run

when your robot senses a light.
The light sensor senses infrared light, so light must be emitted

from an incandescent light, not an LED light.
Page
Note: It has a built-in calibration routine that will come up on the screen
(a step-by-step guide for this calibration routine is on a following slide).
For our activities, you can use a flashlight.
The more light (infrared) detected, the lower the reported value.
: 156

1993 2017 KIPR
Plug in your light sensor

(and get your flashlight!)
Sensor Plug
Orientation
Digital Sensor
Ports # 0 9
Analog Sensor
Ports # 0-5
Plug your Light

Sensor into Analog
Port #0.
Page
: 157

1993 2017 KIPR
Use the sensor list
Page
: 158

1993 2017 KIPR
Use the sensor graph
Page
: 159

1993 2017 KIPR
Starting with a light

Description: Write a program for the KIPR Wallaby that waits for a
light to come on, drives the DemoBot forward for 3 seconds, and
Flowchart
then stops.
Begin

Pseudocode
Comments
1.
2.
3.
4.
5.
// 1. Wait for light.
Wait for light.

Drive forward.
Wait for 3 seconds.
Stop motors.
End the program.
Wait for light.

Drive forward.
Wait for 3 seconds.
Stop motors.
// 4. Stop motors.
Return 0.
End
Page
: 160

1993 2017 KIPR
wait_for_light calibration routine

When you use the wait_for_light() function in your program,
the following calibration routine will run automatically.
When the light is on (low value),

press the Light is On button.
When the light is off (high value),

press the Light is Off button.
Note: For Botball, wait_for_light() should be

one of the first functions called in your program.
Page
: 161

1993 2017 KIPR
You will get a Good Calibration!

message and moving red dot on
green bar when done correctly.
You will get a BAD CALIBRATION
message when not done correctly,
and you will need to run through
the routine again.

Solution:
Source Code
Comments
int main()
{
// 4. Stop motors.
}
int main()
{
wait_for_light(0);
motor(0, 100); //forward
motor(3, 100);
ao();
return 0;
}

Page
: 162

1993 2017 KIPR

Source Code
int main()
{
wait_for_light(0);
Comments
int main()
{
// 4. Stop motors.
}
drive_forward();
ao();
return 0;
}
{
motor(0, 100);
motor(3, 100);
}

Page
: 163

1993 2017 KIPR
Detecting touch
wait_for_touch(port #);
Digital Port #0 9
The wait_for_touch() function pauses your program until a digital sensor

on the specified port # reads a value of 1 (pressed or touched).
Note: Unlike wait_for_light(), it does not have a built-in calibration
routine because it is not necessarytouched is touched!
There are many digital sensors in your kit that can detect touch
Large touch
Small touch
Lever touch
Select the one that can be easily attached and can easily detect the objects.
Page
: 164

1993 2017 KIPR
Using wait_for_touch
What is this?
int main()
{
wait_for_touch(8);
printf("Im touched!\n");
return 0;
}
Page
: 165

1993 2017 KIPR
Drive until touched

DemoBot forward until it detects a touch, then stops.
Page
Use a lever touch sensor.

Plug the lever touch sensor into any of the digital sensor ports (#0 9).
You can either attach the sensor to your robot, or hold it in your hand and
manually press it whenever you would like the robot to stop.
: 166

1993 2017 KIPR
Drive until touched

DemoBot forward until it detects a touch, then stops.
Flowchart
Begin
Pseudocode
Comments
1.
2.
3.
4.
Drive forward.
Wait for touch.
Stop motors.
End the program.
// 2. Wait for touch.
Drive forward.
Wait for touch.
// 3. Stop motors.
Stop motors.
Return 0.
End
Page
: 167

1993 2017 KIPR
Drive until touched

Solution:
Source Code
Comments
int main()
{
// 3. Stop motors.
}
int main()
{
motor(0, 100);
motor(3, 100);
wait_for_touch(8);
ao();
return 0;
}

Page
: 168

1993 2017 KIPR
Drive until touched

Comments
int main()
{
// 3. Stop motors.
}
Source Code
int main()
{
drive_forward();
wait_for_touch(8);
ao();
return 0;
}
{
motor(0, 100);
motor(3, 100);
}

Page
: 169

1993 2017 KIPR
Drive until touched

What happens if the robot goes too fast?
How does wait_for_touch() work?
How can I write my own version of something like it?
To do this, we go back to our concept of using a loop (see next section).
Page
: 170

1993 2017 KIPR
More Repetition, Repetition, Repetition

Program flow control with sensor driven loops
Page
: 171

1993 2017 KIPR
Remember loops?
How does the wait_for_light() function work?
We can use a loop, which controls the flow of the program by

repeating a block of code until a sensor reaches a particular value.
Page
: 172
The number of repetitions is unknown

The number of repetitions depends on the conditions sensed by the robot

1993 2017 KIPR
Using while loops

What is this?
int main()
{
while (digital(8) == 0)
{
motor(0, 100);
motor(3, 100);
}
ao();
return 0;
}
Page
: 173

1993 2017 KIPR
What does this say?
Using while loops
While the touch sensor

is not pressed (== 0),
move forward.
Page
: 174
int main()
{
{
motor(0, 100);
motor(3, 100);
}
ao();
return 0;
}

1993 2017 KIPR
What does this say?
while and Boolean operators examples
{
}
{
}
while (analog(3) < 512)
{
}
while (countdown >= 1)
{
}
Page
: 175

1993 2017 KIPR
Drive until sensor is pressed

DemoBot forward until a touch sensor is pressed, and then stops.
Pseudocode
Comments
1.
2.
3.
4.
Page
Drive forward.
Loop: Is not touched?
Stop motors.
End the program.
: 176
// 2. Loop: Is not touched?

// 3. Stop motors.

1993 2017 KIPR

Analysis: Flowchart
Begin
NO
Is not
touched?
YES
Drive forward.
Stop motors.
Return 0.
End
Page
: 177

1993 2017 KIPR

Solution:
Source Code
Comments
int main()
{
//
1.1. Drive forward.
// 2. Stop motors.
}
int main()
{
{
motor(0, 100);
motor(3, 100);
}
ao();
return 0;
}
Page
: 178

1993 2017 KIPR
Making a Choice
Program flow control with conditionals
if-else conditionals
if-else and Boolean operators
Using while and if-else
Page
: 179

1993 2017 KIPR
What if we want to execute a block of code only if certain

conditions are met?
We can do this using a conditional, which controls the flow of the

program by executing one block of code if its conditions are met
or a different block of code if its conditions are not met.
Page
: 180
This is similar to the loop, but differs in that it only executes once.

1993 2017 KIPR
Begin
Is it
touched?
YES
Print Touched!
NO
Print Not touched!
Code after conditional.
End
Page
: 181

1993 2017 KIPR

This part of the code
is the conditional.
Begin
Is it
touched?
YES
Print Pressed!
NO
Print Not pressed!
Code after conditional.
End
Page
: 182

1993 2017 KIPR
Pseudocode
Comments
1.
//
2.
3.
If: Is touched?
1. Print Touched!.
Else.
1. Print Not touched!.
End the program.
//
//
//
//
1. If: Is touched?
1.1. Print Touched!.
2. Else.
2.1. Print Not touched!.
3. End the program.
In the C programming language,

we accomplish this with an if-else conditional.
Page
: 183

1993 2017 KIPR
The if-else conditional checks to see if a Boolean test is true or false
If the test is true, then the if conditional executes the block of code that immediately follows it.
If the test is false, then the if conditional does not execute the block of code, and the else block of
code is executed instead.
int main()
{
if (Boolean test)
{
// Code to execute ...
}
else
{
}
return 0;
}
Page
: 184

1993 2017 KIPR
Using if-else conditionals

What is this?
int main()
{
if (digital(8) == 1)
{
printf(Touched!\n");
}
else
{
printf(Not touched!\n");
}
return 0;
}
Page
: 185

1993 2017 KIPR
What does this say?
Using if-else conditionals
int main()
{
if (digital(8) == 1)
{
printf(Touched!\n");
}
else
{
printf(Not touched!\n");
}
return 0;
}
Page
: 186

1993 2017 KIPR
(Why not?)
int main()
{
// Code before conditional ...
if (Boolean test)
{
// Code to execute if test is true
}
else
{
// Code to execute if test is false
}
The else is below

the } brace of the
if block of code!
return 0;
}
Page
: 187

1993 2017 KIPR
if-else examples
if (right_button() == 0)
{
}
else
{
}
if (analog(3) < 512)
{
}
else
{
}
Page
: 188

1993 2017 KIPR
Example using while and if-else
int main()
{
while (right_button() == 0)
{
if (analog(0) > 512)
{
printf("Its dark in here!\n");
}
else
{
}
} // loop ends when button is pressed
return 0;
}
Page
: 189

1993 2017 KIPR
What do these
lines of code say?
Note the ==
(2 equal signs)
Using while and if-else
Notice how the { and }

braces line up for each
block of code!
Page
: 190
int main()
{
{
{
printf("Its dark in here!\n");
}
else
{
}
} // loop ends when button is pressed
return 0;
}

1993 2017 KIPR
Reflectance sensor for line-following

For this activity, you will need a reflectance sensor.
This sensor is really a short-range reflectance sensor.

There is both an infrared (IR) emitter and an IR detector inside of this sensor.
IR emitter sends out IR light IR detector measures how much reflects back.
The amount of IR reflected back depends on many factors, including surface
texture, color, and distance to surface.
This sensor is excellent for line-following!
Page
Black materials typically absorb most IR they reflect little IR back!

White materials typically absorb little IR they reflect most IR back!
If this sensor is mounted at a fixed height above a surface, it is easy to
distinguish a black line from a white surface.
: 191

1993 2017 KIPR
Attach your reflectance sensor
Attach the sensor on the front of your robot so that it is pointing

down at the ground and is approximately 1/8 from the surface.
A reflectance sensor is an analog sensor, so plug it into any of
analog sensor port #0 5. Port 0 for this example.
Recall that analog sensor values range from 0 to 4095.
Sensor Plug
Orientation
Surface
Analog Sensor
Ports # 0 5
Page
: 192

1993 2017 KIPR
Reading sensor values

from the Sensor List screen
View sensor values from the Sensor List on your KIPR Wallaby.
This is very helpful to view readings from all of the sensors you are using.
You can view the values, then use them in your code.
Select Sensor List.
Page
: 193
Sensor Ports
1993 2017 KIPR
Sensor Values
Reading sensor values

With the reflectance sensor plugging into analog port #0
Over a black surface, the sensor reading is 3863.

Over a white surface, the sensor reading is 156.
Value of 3863
(Black Surface)
Page
: 194

1993 2017 KIPR
Your values will be

different, but the process
will be the same!
Value of 156
(White Surface)

Starting with your DemoBot on one end of JBC Mat 2 or
using a piece of dark tape, have the robot travel along the
path of the tape using the Top Hat sensor to determine the
robot path (line following).
Page
: 195

1993 2017 KIPR
Page
: 196

1993 2017 KIPR
Line-following
Analysis: Flowchart
Begin
Is not
pressed?
NO
YES
YES
Is dark
detected?
Turn/arc left.
NO
Turn/arc right.
Stop motors.
Return 0.
End
Page
: 197

1993 2017 KIPR
Line-following with functions

Solution: (using two functions)
int main()
{
// 1. Loop: Is not pressed?
//
1.1. If: Is dark detected?
//
1.1.1. Turn/arc left.
//
1.2. Else:
//
1.2.1. Turn/arc right.
// 2. Stop motors.
}
void turn_left();
void turn_right();
int main()
{
{
{
turn_left();
}
else
{
turn_right()
}
}
ao();
return 0;
}
void turn_left()
{
motor(0, 20);
motor(3, 100); // Turn/arc left.
}
Page
: 198
void turn_right()
{
motor(0, 100);
motor(3, 20); // Turn/arc right.
}
1993 2017 KIPR
Homework
Game review
Game strategy
Workshop survey
Page
: 199

1993 2017 KIPR
Homework for tonight:

game review
Visit http://homebase.kipr.org
Review the game rules on your Team Home Base.
We will have a 30-minute Q&A session tomorrow.

After the workshop, ask questions about game rules in
the Game Rules Forum.
You should regularly visit this forum.

You will find answers to the game questions there.
Page
: 200

1993 2017 KIPR

game strategy
Break down the game into subtasks!
Write pseudocode and/or create flowcharts!

Start with easy pointsscore early and score often!
Keep it simple and make sure it works.
Discuss your strategy with your instructor tomorrow.
Page
: 201

1993 2017 KIPR

game strategy
Think about the
Engineering Design Process!
Page
: 202

1993 2017 KIPR

workshop survey
Please take our survey to give feedback about the workshop:

https://www.surveymonkey.com/r/LCYB7RY
Page
: 203

1993 2017 KIPR
Have a good night!

Visit http://homebase.kipr.org
Page
: 204

1993 2017 KIPR
Welcome back!
Botball 2017
Prepared by the KISS Institute for Practical Robotics (KIPR)
with significant contributions from KIPR staff
and the Botball Instructors Summit participants
v2017.01.06-2
Page
: 205

1993 2017 KIPR
Workshop Schedule
Day 1
Page
Day 2
Botball Overview
Getting started with the KISS IDE
Fun with Functions
Repetition, Repetition: Counting
Repetition, Repetition: Reacting
Botball Game Review

Measuring Distance
Color Camera
Logical Operators
Making a Choice
Line-following
Homework
: 206

1993 2017 KIPR
Botball Game Review

Game Q&A
Construction, documentation, and changes
Tournament template
shut_down_in() function
Page
: 207

1993 2017 KIPR
Botball Game Q&A starts
NOW!
You have 30 minutes
Page
: 208

1993 2017 KIPR
Botball game board
Page
: 209

1993 2017 KIPR
Ideas on construction
Note: our competition tables are built
to specifications with allowable variance.
Do NOT engineer robots that are so precise that a 1/4 difference

in a measurement means they are not successful.
Page
For example: the specified height of the elevated platform is 15-3/4, but at
the tournament the platform could actually measure 15-7/8. If your arm is
set for exactly 15-3/4, it would not work.
Review construction documents (like the ones on the Home

Base!) to get building ideas.
Search the internet for robots and structures to get building ideas.
Test structure robustness before the tournament!
: 210

1993 2017 KIPR
Documentation
What?
Botball Online Project Documentation (BOPD)

Rubrics and examples are on the Team Home Base
NO NAMES OR SCHOOL NAMES ALLOWED ON SUBMISSIONS
When?
3 document submissions during design and build portion

1 onsite presentation (8 minute) at regional tournament
Why?
To reinforce the Engineering Design Process

Points earned in Documentation factor into the overall tournament scores!
See BOPD Handbook on the Team Home Base

for more information (rubrics and exemplars).
Page
: 211

1993 2017 KIPR
Changes this season
Page
See the Team Homebase for a document covering all changes made in regards
to Hardware, Rules, the Wallaby, Software, and Documentation.
: 212

1993 2017 KIPR
Tournament templates
int main() // for your Create robot
{
create_connect();
wait_for_light(0); // change the port number to match the port you use
shut_down_in(119); // shut off the motors and stop the robot after 119 seconds
// Your code
create_disconnect();
return 0;
}
int main() // for not your Create robot

{
wait_for_light(0); // change the port number to match the port you use
shut_down_in(119); // shut off the motors and stop the robot after 119 seconds
// Your code
return 0;
}
Page
: 213

1993 2017 KIPR
Botball tournament functions

These two functions should be
two of the first lines of code in
your Botball tournament program!
wait_for_light(0);
// Waits for the light on port #0 before going to the next line.
shut_down_in(119);
// Shuts down all motors after 119 seconds (just less than 2 minutes).
Page
This function call should come immediately after the wait_for_light() in your code.
If you do not have this function in your code, your robot will not automatically turn off
its motors at the end of the Botball round and you will be disqualified!
: 214

1993 2017 KIPR
Running a Botball tournament program

Description: Write a program for the KIPR Wallaby that waits for a
light to come on, shuts down the program in 5 seconds, drives the
DemoBot forward until it detects a touch, and then stops.
Pseudocode
Comments
1.
2.
3.
4.
5.
6.
Page
Wait for light.

Shut down in 5 seconds.
Drive forward.
Wait for touch.
Stop motors.
End the program.
: 215
// 2. Shut down in 5 seconds.

// 5. Stop motors.

1993 2017 KIPR

Analysis:
Flowchart
START
Wait for light.

Shut down in 5 seconds.
Drive forward.
Wait for touch.
Stop motors.
Return 0
STOP
Page
: 216

1993 2017 KIPR

Solution:
Source Code
int main()
{
wait_for_light(0);
int main()
{
// 2. Shut down in 5 seconds.
// 5. Stop motors.
}
shut_down_in(5);
motor(0, 100);
motor(3, 100);
wait_for_touch(8);
ao();
return 0;
}

Page
: 217

1993 2017 KIPR
wait_for_light() calibration routine

When you use the wait_for_light() function in your program,
the following calibration routine will run automatically.
When the light is on (low value),

press the Light is On button.
When the light is off (high value),

press the Light is Off button.
Note: For Botball, wait_for_light() should be

one of the first functions called in your program.
Page
: 218

1993 2017 KIPR
You will get a Good Calibration!

message and moving red dot on
green bar when done correctly.
You will get a BAD CALIBRATION
message when not done correctly,
and you will need to run through
the routine again.

Reflection:
What happens if the touch sensor is pressed in less than 5 seconds after
starting the program?
What happens if the touch sensor is not pressed in less than 5 seconds after
starting the program?
What is the best way to guarantee that your program will start with the light in
a Botball tournament round? (Answer: wait_for_light())
What is the best way to guarantee that your program will stop within 120
seconds in a Botball tournament round? (Answer: shut_down_in())
Use these functions in your Botball tournament code!

Page
: 219

1993 2017 KIPR

Motor position counter functions
Ticks and revolutions
Page
: 220

1993 2017 KIPR
Motor position counter

Each motor used by the DemoBot has a built-in motor position counter,
which you can use to calculate the distance traveled by the robot!
Motor Port #
(#0 3)
get_motor_position_counter(3)
OR
gmpc(3)
// Tells us the number of ticks the motor on port #3 has rotated.
// Note: gmpc is shorthand for get_motor_position_counter.
Motor Port #
(#0 3)
clear_motor_position_counter(3);
OR
cmpc(3);
// Resets the tick counter to 0 for the motor on port #3.
// Note: cmpc is shorthand for clear_motor_position_counter.
Page
Similar to how a clock is divided into

60-second intervals (ticks).
The motor position is measured in ticks.

Botball motors have approximately 1400 ticks per revolution.
Use wheel circumference divided by 1400 to calculate distance!
: 221

1993 2017 KIPR
Using motor position counter functions

How many revolutions
will the motor rotate?
int main()
{
while (get_motor_position_counter(3) < 1400)
{
motor(3, 50);
}
ao();
return 0;
}
Page
: 222

1993 2017 KIPR
Drive a specific number of revolutions

DemoBot forward for 10 motor revolutions, and then stops.
Pseudocode
Comments
1.
2.
// 1. Reset motor position counters.
3.
4.
Reset motor position counters.

1. Drive forward.
Stop motors.
End the program.

//
2.1. Drive forward.
// 3. Stop motors.
Why
14000?
Page
: 223

1993 2017 KIPR

Solution:
Source Code
Comments
int main()
{
//
2.1. Drive forward.
// 3. Stop motors.
}
int main()
{
if (get_motor_position_counter(0) < 14000)
{
// 2.1 Drive forward.
motor(0, 100);
motor(3, 100);
}
ao(); // 3. Stop motors.
return 0; //4. End the program.
}
Page
: 224

1993 2017 KIPR

How far did the robot travel? Was it always the same?
How could you calculate an exact distance in millimeters to travel?

(Hint: Use wheel circumference divided by 1400 to calculate distance!)
How could you modify your program to travel a specific distance in millimeters?
(Hint: Consider writing a function with an argument for the distance.)
How could you modify your program to accurately turn left or right?
Page
: 225

1993 2017 KIPR
Drive Straight!
DemoBot straight for 14000 tics by adjusting the left motor power so that
the position of the left motor is the same (or close) to the right.
Analysis: How can you adjust the left motors position?
Pseudocode
1.
2.
Reset motor position counters.

1. Move right motor at 75% power
2. Is left wheel behind right?
1.
2.
3.
4.
Page
Comments
True: speed up left

motor at 100%
False: slow down left
motor at 50%
Stop motors.
End the program.
: 226
// 1. Reset motor position counts.
// 2. Loop: check right position.

// 2.1 power right motor at 75%
// 2.2 compare left to right counters
// 2.2.1 slower: power left
// 2.2.2 faster: power left
// 3. Stop motors.
1993 2017 KIPR
Drive Straight!
Solution:
Source Code
int main()
{
// 1. clear both motor counters
clear_motor_position_counter(0); // left motor
cmpc(3); // right motor (shorter name)
// 2. Loop: check right position.
while(get_motor_position_counter(3) < 14000)
{
// 2.1 power right motor at 75%
motor(3, 75);
int main()
{
// 1. clear both motor counters.
// 2. Loop: check right position
//
2.1. power right motor at 75%.
//
2.2. compare left to right counters.
//
2.2.1. slower: left motor at 100%.
//
2.1.2. faster: left motor at 50%.
// 3. Stop motors.
// 2.2 compare left to right counters

if(gmpc(0) < gmpc(3))
{ // 2.2.1 slower: power left motor at 100%
motor(0, 100);
}
else
{ // 2.2.2 faster: power left motor at 50%
motor(0, 50);
}
}
ao(); // 3. Stop motors.
}
Page
: 227

1993 2017 KIPR
Drive Straight
Did the robot go straighter than in the previous program?
How could you use this technique whenever you wanted to drive straight?
(Hint: Consider writing a function with an argument for the distance.)
How could you modify your program to go straight at different speeds?
Page
: 228

1993 2017 KIPR
Measuring Distance
Infrared ET distance sensor
Page
: 229

1993 2017 KIPR
Infrared ET distance sensor
For this activity, you will need the infrared ET distance sensor.
There is both an infrared (IR) emitter and an IR detector inside of this sensor.
The sensor works by sending out an IR beam and then measures the angle the
reflected IR light returns at and triangulates the distance to an object.
This sensor makes a great medium-range distance sensor.
Page
Values are reliable between 5 cm and 80 cm.

Values are not reliable beyond these distances, though they appear to be!
Values are in raw sensor units, not in centimetersbut you can convert!
Values decrease as an object gets farther away from the sensor.
: 230

1993 2017 KIPR
Attach your ET distance sensor
Attach the sensor on the front of your robot so that it is pointing

forward.
The ET distance sensor is an analog sensor, so plug it into any of
analog sensor port #0 5. For the purpose of this example, we
will use analog port 5.
Recall that analog sensor values range from 0 to 4095.
Sensor Plug
Orientation
Analog Sensor
Ports # 0 5
Page
: 231
Analog Sensor
Ports 5

1993 2017 KIPR
Reading ET distance sensor values

Hold an object in front of the ET distance sensor at different
distances and read the value on the Sensor List screen.
Higher values closer distances.
Page
: 232
3
1993 2017 KIPR
Lower values farther distances.
ET distance grabbing
To get sensor readings from the ET distance sensor,
you must call the analog function:
analog(5) // Get a reading from analog port #5.
Page

Range: 5 cm 80 cm
: 233
Values are not reliable beyond these distances, though they appear to be!

1993 2017 KIPR
Using analog for ET

What does this say?
int main()
{
while (analog(5) < 475)
{
motor(0, 100);
motor(3, 100);
}
ao();
return 0;
}
(Why not?)
Remember
Page
: 234

1993 2017 KIPR
Maintain distance
Description: Write a program for the KIPR Wallaby that makes the
DemoBot maintain a specified distance away from an object, and stops
when the touch sensor is touched.
Pseudocode
1.
Loop: Is not touched?

1. If: Is distance too far?
1. Drive forward.
2. Else.
Comments
//
//
//
1. If: Is distance too close? //

1. Drive reverse.
//
2. Else:
1. Stop motors.
//
2.
3.
Page
Stop motors.
End the program.
: 235
1.1. If: Is distance too far?

1.1.1. Drive forward.
1.2. Else.
1.2.1. If: Is distance too close?
1.2.1.1. Drive reverse.
//
1.2.2. Else.
1.2.2.1. Stop motors.
// 2. Stop motors.

1993 2017 KIPR
Maintain distance
Source Code
Solution:
Comments
int main()
{
//
1.1. If: Is distance to far?
//
1.1.1. Drive forward.
//
1.2. Else.
//
1.2.1. If: Is distance too close?
//
1.2.1.1. Drive reverse.
//
1.2.2. Else.
//
1.2.2.1. Stop motors.
// 2. Stop motors.
}
Page
: 236
int main()
{
{
// 1.1. Is distance too far?
if (analog(5) < 475)
{
motor(0, 100);
motor(3, 100);
}
else // sensor value is 475 or greater
{
// 1.2.1. If: Is distance too close?
{
motor(0, -100);
motor(3, -100);
}
else // sensor value is 475-525
{
ao();
}
}
}
ao();
return 0;
Professional Development
} Workshop
1993 2017 KIPR

Setting up the Create
The Create and the KIPR Wallaby
Create functions
Page
: 237

1993 2017 KIPR
Charging the Create
For charging the Create, use only the power supply

which came with your Create.
Damage to the Create from using the wrong charger is easily

detected and will void your warranty!
The Create power pack is a nickel metal hydride

battery, so the rules for charging a battery for any
electronic device apply.
Only an adult should charge the unit.

Do NOT leave the unit unattended while charging.
Charge in a cool, open area away from flammable materials.
Page
: 238

1993 2017 KIPR
Enabling the battery of the Create

The yellow battery tab pulls out of place on the bottom of the Create.
The battery will be enabled as soon as the tab is removed.
Create
Underside
Page
: 239

1993 2017 KIPR
Uncovering and Charging the Create

Remove the green protective tray from the top of the Create.
Use only the Create charger provided with your kit.
The Create docks onto the charging station.
Remove this
Page
: 240
Serial
Port
1993 2017 KIPR
Mounting the Robotics Controller onto

the Create
Build the Create DemoBot
Page
: 241

1993 2017 KIPR
Create connect/disconnect functions
All programs used with the Create

MUST start with
create_connect()
and end with
create_disconnect()
Flowchart
Begin
Connect to Create
Drive forward 2 seconds.

Turn off motors
Disconnect from Create
End
Page
: 242

1993 2017 KIPR
Create motor functions

Note: Create commands run until a different motor command is received.
create_drive_direct(left speed, right speed);
Left Motor Speed
(in mm/second)
Right Motor Speed

(in mm/second)
Examples:
create_drive_direct(100, 100);
// Moves forward at 100 mm/sec.
create_drive_direct(-200, 200);
// Create will turn left.
create_drive_direct(150, -150);
// Create will turn right.
create_stop();
// Turns off the Create motors.
WARNING: the maximum speed for the Create motors is 500 mm/second = 0.5 m/second.
It can jump off a table in less than one second!
Use something like 200 for the speed (moderate speed) until teams get the hang of this.
Page
: 243

1993 2017 KIPR
Using Create functions
int main()
{
create_connect();
create_stop();
return 0;
}
Page
: 244

1993 2017 KIPR
How far will the

Create drive?
Moving the Create

Create forward at 100 mm/second for four seconds, and then stops.
Pseudocode
Comments
1.
2.
3.
4.
5.
6.
// 1. Connect to Create.
Page
Connect to Create.
Drive forward at 100 mm/sec.
Wait for 4 seconds.
Stop motors.
Disconnect from Create.
End the program.
: 245
// 2. Drive forward at 100 mm/sec.

// 4. Stop motors.
// 5. Disconnect from Create.

1993 2017 KIPR
Moving the Create

Analysis:
Flowchart
Begin
Connect to Create.
Drive forward at 100 mm/sec.
Wait for 4 seconds.

Stop motors.
Return 0.
End
Page
: 246

1993 2017 KIPR
Moving the Create

Source Code
Solution:
int main()
{
create_connect();
Comments
int main()
{
// 4. Stop motors.

// 4. Stop motors.
create_stop();
}
return 0;
}

Page
: 247

1993 2017 KIPR
Touch an object and go home

Create forward until it touches an object (or gets as close as it can),
and then returns to its starting location (home).
Move the object to various distances.
Starting line
iRobot
Create
Object
Starting line
Object
iRobot
Create
Page
: 248

1993 2017 KIPR
Starting line
iRobot
Create
Object

Create distance and angle functions
Page
: 249

1993 2017 KIPR
Create distance/angle functions

The Create has a built-in sensor that measures
the distance traveled (in millimeters) and
the angle turned (in degrees).
This is similar to the

motor position counter...
but better!
get_create_distance()
// Tells us the distance the Create has traveled in mm.
set_create_distance(0);
// Resets the Create distance traveled to 0 mm.
get_create_total_angle()
// Tells us the total angle the Create has turned in degrees.
// Positive angles are to the left. Negative angles are to the right.
set_create_total_angle(0);
// Resets the Create angle turned to 0 degrees.
Page
: 250

1993 2017 KIPR
Using Create distance functions

What does this say?
int main()
{
create_connect();
set_create_distance(0);
while (get_create_distance() < 1000)
{
}
create_stop();
return 0;
}
Page
: 251

1993 2017 KIPR
Using Create angle functions

What does this say?
int main()
{
create_connect();
while (get_create_total_angle() < 90)
{
}
create_stop();
return 0;
}
Page
: 252

1993 2017 KIPR

Positive angles
are to the left
(counter-clockwise).
int main()
{
create_connect();
while (get_create_total_angle() < 90)
{
}
create_stop();
return 0;
}
Page
: 253

1993 2017 KIPR

Negative angles
are to the right
(clockwise).
int main()
{
create_connect();
while (get_create_total_angle() > -90)
{
create_drive_direct(200, -200);
}
create_stop();
return 0;
}
Page
: 254

1993 2017 KIPR
Notice:
the signs changed!

Create sensor functions
Logical operators
Page
: 255

1993 2017 KIPR

To get Create sensor values, type get_create_sensor(),
replacing sensor with the name of the sensor
rclightbump
rflightbump
lclightbump
cwdrop
rfcliff
lfcliff
rbump
lbump
rlightbump
rcliff
llightbump
battery_capacity
rwdrop
: 256
lcliff
lwdrop
distance
Page
lflightbump
total_angle
1993 2017 KIPR

get_create_lbump()
get_create_rbump()
// Tells us if the Create left/right bumper is pressed.
// Like a digital touch sensor.
get_create_lwdrop()
get_create_rwdrop()
get_create_cwdrop()
// Tells us if the Create left/right/center wheel is dropped.
// Like a digital touch sensor.
get_create_lcliff()
get_create_lfcliff()
get_create_rcliff()
get_create_rfcliff()
// Tells us the Create left/left-front/right/right-front cliff sensor value.
// Like an analog reflectance sensor.
get_create_battery_capacity()
// Tells us the Create battery level (0-100).
Page
: 257

1993 2017 KIPR
Using Create sensor functions

What does this say?
int main()
{
create_connect();
while (get_create_rbump() == 0)
{
}
create_stop();
return 0;
}
Page
: 258

1993 2017 KIPR
Drive until bumped

Create forward until a bumper is pressed, and then stops.
Pseudocode
Comments
1.
2.
3.
4.
5.
Page
Connect to Create.
Loop: Is not bumped?
1. Drive forward.
Stop motors.
End the program.
: 259
// 2. Loop: Is not bumped?

//
2.1. Drive forward.
// 3. Stop motors.

1993 2017 KIPR
Drive until bumped

Analysis: Flowchart
Begin
Connect to Create.
NO
Is not
bumped?
YES
Drive forward.
Stop motors.
Return 0.
End
Page
: 260

1993 2017 KIPR
Drive until bumped

Solution:
Source Code
int main()
{
create_connect();
Comments
int main()
{
//
2.1. Drive forward.
// 3. Stop motors.
}

while (get_create_rbump() == 0)
{
// 2.1. Drive forward.
} // end while
// 3. Stop motors.
create_stop();
return 0;
} // end main
Page
: 261

1993 2017 KIPR

Make the iRobot Create move forward in a straight line
until it comes into contact with another object. Then have
it make a 90 turn and again travel in a straight line for
exactly 0.9 meters.
Page
: 262

1993 2017 KIPR
Page
: 263

1993 2017 KIPR
LUNCH
Page
: 264

1993 2017 KIPR
Color Camera
Using the color camera
Setting the color tracking channels
About color tracking
Camera functions
Page
: 265

1993 2017 KIPR
Color camera
For this activity, you will need the black camera.
The camera plugs into one of the USB (type A) ports on the back of the Wallaby.
Warning: Unplugging the camera while it is being accessed can freeze the
Wallaby, requiring it to be rebooted.
USB Ports
Page
: 266

1993 2017 KIPR

1. Select Settings
2. Select Channels
2
1
Page
: 267

1993 2017 KIPR

3. To specify a camera configuration, press the Add button.
4. Enter a configuration name, such as find_green, then press the
Ent button.
5. Highlight the new configuration and press the Edit button.
4
3
Note: if there is more than one configuration, select one, and
press the Default button to make it be the one in use!
Page
: 268

1993 2017 KIPR

6. Press the Add button to add a channel to the configuration.
7. Select HSV Blob Tracking, then OK to make this track color.
8. Highlight the channel, then press Configure to edit settings.
The first channel is 0 by default. You can have up to four: 0, 1, 2, and 3.
6
Page
: 269

1993 2017 KIPR

9. Place the colored object you want to track in front of the camera
and touch the object on the screen.
A bounding box (dark blue) will appear around the selected object.
10. Press the Done button.
9
10
Page
: 270

1993 2017 KIPR
Verify the color channel is working

1.
2.
3.
From the Home screen, press Motors and Sensors button.

Press the Camera button.
Objects specified by the configuration should have a bounding box.
1
2
Page
: 272

1993 2017 KIPR
Tracking the location of an object
You can use the position of the object in relation to the

center x (column) of the image to tell if it is to the left or right.
The image is 160 columns wide, so the center column (x-value) is 80.
An x-value of 80 is straight ahead.
An x-value between 0 and 79 is to the left.
An x-value between 81 and 159 is to the right.
You can also use the position of the object in relation to the center y (row) of
the image to tell how far away it is.
Object
(0, 0)
(80, 0)
0, 1, 2,
(largest to smallest)
(159, 0)
Channel #
Left
(0, 119)
Page
: 273
Right
(80, 119)
get_object_center_x(0, 0);
// The x-value of the tracked object.
// Note: number between 0 and 159.
(159, 119)
1993 2017 KIPR
Camera functions
camera_open();
// Opens the connection to the camera.
camera_close();
// Closes the connection to the camera.
camera_update();
// Gets a new picture (image) from the camera and performs color tracking.
get_object_count(channel #)
// The number of objects being tracked on the specified color channel.
get_object_center_x(channel #, object #)
// The center x (column) coordinate value of the object # on the color channel.
get_object_center_y(channel #, object #)
// The center y (row) coordinate value of the object # on the color channel.
Page
: 274

1993 2017 KIPR
Using camera functions

int main()
{
camera_open();
{
camera_update();
if (get_object_count(0) == 0)
{
printf("No objects detected.\n");
}
else
{
if (get_object_center_x(0, 0) < 80)
{
printf("Object is on the left!\n");
}
else
{
printf("Object is on the right!\n");
}
}
}
camera_close();
return 0;
}
Page
: 275

1993 2017 KIPR
What do these say?

Calibrate and program the robot and camera combination
so that it will turn on its axis in response to Botguy moving
to the left or right in front of it.
Page
: 276

1993 2017 KIPR
Page
: 277

1993 2017 KIPR
Logical Operators
Multiple Boolean tests
while, if, and Logical operators
Page
: 278

1993 2017 KIPR
Logical operators
Recall the Boolean test for while loops and if-else conditionals
while (Boolean test)
if (Boolean test)
The Boolean test (conditional) can contain multiple Boolean tests

combined using a Logical operator, such as:
&&
||
!
And
Or
Not
We put parentheses ( and )

around each Boolean test
while ((Boolean test 1) && (Boolean test 2))

if ((Boolean test 1) || (!Boolean test 2))
Page
The next slide provides a cheat sheet for Logical operators.

: 279

1993 2017 KIPR
Logical operators cheat sheet
Boolean
A && B
A || B
!(A && B)
!(A || B)
English Question
True Example
False Example
Are both A and B true?
true && true
true && false

false && true
false && false
Is at least one of A or B true?
true || true
false || true
true || false
false || false
Is at least one of A or B false?
true && false

false && true
false && false
true && true
false || false
true || true
false || true
true || false
Are both of A and B false?
! negates the true or false Boolean test.

Page
: 280

1993 2017 KIPR
while, if, and Logical operators

examples
while ((get_create_lbump() == 0) && (get_create_rbump() == 0))
{
}
while ((digital(14) == 0) && (digital(15) == 0))
{
}
if ((digital(12) == 1) || (digital(13) != 0))
{
}
if ((analog(3) < 512) || (digital(12) == 1))
{
}
Page
: 281

1993 2017 KIPR
Using Logical operators

What does this say?
int main()
{
create_connect();
while ((get_create_lbump() == 0) && (get_create_rbump() == 0))
{
}
create_stop();
return 0;
}
Page
: 282

1993 2017 KIPR
Drive for distance or until bumped

Description: Write a program for the KIPR Wallaby that drives the Create
forward for 1 meter or until a bumper is pressed, and then stops.
How do we check for distance traveled? Answer: get_create_distance() < 1000

How do we check for bumper pressed? Answer: get_create_rbump() == 0
How do we check for that both are true?
Answer: ((get_create_distance()) < 1000) && (get_create_rbump() == 0))
Pseudocode
1.
2.
3.
4.
5.
Page
Comments
Connect to Create.
Loop: Is distance < 1000 AND not bumped?
1. Drive forward.
Stop motors.
End the program.
: 283
// 2. Loop: Is distance < 1000 AND not bumped?
//
2.1. Drive forward.
// 3. Stop motors.


1993 2017 KIPR

Analysis: Flowchart
Begin
Connect to Create.
NO
Is distance <
1000
AND not
bumped?
YES
Drive forward.
Stop motors.
Return 0.
End
Page
: 284

1993 2017 KIPR

Solution:
Source Code
int main()
{
// 2. Loop: Is distance < 1000
//
AND not bumped?
//
2.1. Drive forward.
// 3. Stop motors.
}
int main()
{
create_connect();
// 2. Loop: Is distance < 1000 AND not bumped?
while ((get_create_distance() < 1000) && (get_create_rbump() == 0))
{
// 2.1. Drive forward.
} // end while
// 3. Stop motors.
create_stop();
return 0;
} // end main
Page
: 285

1993 2017 KIPR

What happens if the Create right bumper is pressed before the Create travels a
distance of 1 meter?
What happens if the Create right bumper is not pressed before the Create
travels a distance of 1 meter?
What happens if the Create left bumper is pressed instead?
How could you also check to see if the Create left bumper is pressed? Answer:
while ((get_create_distance()) < 1000) && (get_create_lbump() == 0) && (get_create_rbump() == 0))
Page
: 286

1993 2017 KIPR

Team Home Base
Remind, YAC, Community, PYR, and social media
T-shirts and awards
What to do after the workshop
Page
: 287

1993 2017 KIPR

Found at http://homebase.kipr.org
Page
: 288

1993 2017 KIPR

KIPR Support
E-mail: support@kipr.org
Phone: 405-579-4609
Hours: M-F, 8:30am-5:00pm CT
Forum and FAQ
Page
Site: http://homebase.kipr.org
Content:
Documentation Manual and Examples
Presentation Rubric & Example Presentation
DemoBot Build Instructions & Parts List
Controller Getting Started Manual
Construction Examples
Hints for New Teams
Sensor & Motor Manual
Game Table Construction Documents
All 2017 Game Documents
: 289

1993 2017 KIPR
Botball Remind
https://www.remind.com/join
OK Regional: @393gf7
Page
: 291

1993 2017 KIPR
Botball Youth Advisory Council (YAC)
We are a group of current and former Botballers who form

Botballs student government.
We work on many projects (e.g. blogs, forums, live-streaming),

with one simple mission: keep making Botball better!
Page
: 292

1993 2017 KIPR
Program Your Robot (PYR)
http://botballprogramming.org
Page
: 293

1993 2017 KIPR
Social media
Page
: 294

1993 2017 KIPR
Social media
Page
: 295

1993 2017 KIPR
Tournament awards
Page
: 297

1993 2017 KIPR
Tournament awards
There are a lot of opportunities for teams to win awards!
Page
Tournament Awards
Outstanding Documentation
Seeding Rounds
Double Elimination
Overall (includes Documentation, Seeding, and Double Elimination)
Judges Choice Awards (# of awards depends on # of teams)
: 298
KISS Award
Spirit of Botball
Outstanding Engineering
Outstanding Software
Spirit
Outstanding Design/Strategy/Teamwork
1993 2017 KIPR

1. Recruit team members.
If you havent already recruited team members you can use the materials from
the workshop to show to interested students.
2. Hit the ground running.
Page
: 299
Do not wait to get startedtime is of the essence!

You only have a limited build time before the tournament.
The workshop will still be fresh in your mind if you start now.
Plan on meeting sometime during the first week after the workshop.

1993 2017 KIPR

3. Plan out the season.
Page
: 300
Students will not inherently know how to manage their time. Lets face
itit is difficult for many adults!
Mark a calendar or make a Gannt chart with important dates:
1st online documentation submission due
2nd online documentation submission due
3rd online documentation submission due
Tournament date
Set dates and schedules for team meetings.
Plan on meeting a minimum of 4 hours per week.

1993 2017 KIPR

4. Build the game board.
If you cant build the full game board, you can build of the board.
You could tape the outline of the board onto a floor if you have the right
type of flooring.
4. Organize your Botball kit.
Organized parts can lead to faster and easier construction of robots.
4. Understand the game.
Page
: 301
Go over this with your students on the first meeting after the workshop.

1993 2017 KIPR
Thanks and have a great season!
// end workshop

Page
: 302

1993 2017 KIPR

2017 Botball WorkshopSlides-V2017.01.16

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

2017 Botball WorkshopSlides-V2017.01.16

Diunggah oleh

Hak Cipta:

Format Tersedia

Welcome to Botball 2017!

Before we get started

Sign in, and collect your materials and electronics.

Raise your hand if you need help or have questions.

Professional Development Workshop

Charging the Controllers Battery

For charging the controllers battery, use only the power

It is possible to damage the battery

The standard power pack is a lithium iron

Do NOT leave the battery unattended while charging.

Professional Development Workshop

KRC Wallaby Controller Guide

KIPR Robotics Controller

Making the Connection

All connections are as follows:

Professional Development Workshop

The KIPR Robotics Controller Wallaby, uses an external battery

Make sure to follow the shutdown instruction on the next slide.

Professional Development Workshop

Wallaby Power Down

From the Software Suite select Shutdown

From the Wallaby Home Screen press Shutdown

Go to your Wallaby screen and check to see if it is

Slide the power switch to off AND unplug the

Professional Development Workshop

Build the DemoBots

Professional Development Workshop

Hi! Im Botguy, the Botball mascot!

Professional Development Workshop

Thank you for participating!

KIPRs mission is to:

improve the publics understanding of science, technology, engineering, and math;

Professional Development Workshop

Introductions: workshop staff and volunteers

Workshop schedule: 2 days

Professional Development Workshop

Botball Game Review

Professional Development Workshop

Thanks to our national sponsors!

Professional Development Workshop

Thanks to our regional sponsors!

Professional Development Workshop

Thanks to our regional hosts!

Professional Development Workshop

Professional Development Workshop

Produced by the KISS Institute for Practical Robotics (KIPR), a

Engages middle and high school aged students in a team-oriented

By designing, building, programming, and documenting robots,

Professional Development Workshop

Design, build, & program

Professional Development Workshop

Design, build, & program

YOU ARE HERE!

Provides the skills and tools necessary to compete in the tournament.

Not a standalone curriculum! Goal is to support team success in Botball!

Professional Development Workshop

Design, build, & program

Reinforces computational thinking and the engineering design process.

Professional Development Workshop

Design, build, & program

Onsite documentation: 8-minute technical presentation to judges

Professional Development Workshop

Design, build, & program

Global Conference on Educational Robotics (GCER)