Archive for the ‘Training’ Category
ROBOTC Professional Development Courses
We LOVE summers here at ROBOTC, and one of the main reasons for that is we get to meet tons of awesome teachers, mentors, and coaches at our ROBOTC Professional Development training courses! It’s our chance to meet our users and make sure they’re equipped with a solid foundation in ROBOTC programming to take back with them for a successful new school year; and it’s your chance to meet our team, ask questions, and give us feedback. We have separate courses for LEGO & TETRIX and VEX CORTEX with the option to take the class on-site or online.
Benefits of our On-site courses includes:
✓ Provided hardware and the ROBOTC software in our classrooms.
✓ Over 30+ hours of hands on experience.
✓ Training provided by the developers of the curriculum and software.
✓ Custom course content: We adjust the course to the skill level and desires of the participants.
✓ Mapping of robotics curriculum with national standards.
✓ Tour of the National Robotics Engineering Center.
✓ ACT 48 Credits (for PA teachers.)
✓ Certificate of completion for course “Graduates.”
✓ Lunch provided at no additional cost.
Enjoy these benefits with our Online Training:
✓ Convenient online training from your home or school via the Internet.
✓ Online access to video training material and supplemental lessons from CMU’s Robotics Academy.
✓ 24/7 access to class forums and message boards (monitored regularly.)
✓ Screen sharing and live discussion amongst the class.
✓ Technical support for all hardware and software used in the class.
✓ Networking opportunities with other professional educators.
In every Professional Development course, you will have the opportunity to take the certification exam to become a “Robotics Academy Certified Instructor.”
Contact training@rec.ri.cmu.edu to learn more!
FAQ:
- Does this course offer college credit?
- The course offers continuing education credit and documents that you have participated in 36 hours worth of instruction at Carnegie Mellon’s Robotics Academy. It is not a college credit course.
- What happens if I don’t pass the certification test?
- The certification test is offered after you complete the course. If you don’t pass the certification test, you will have the opportunity to retake the exam one month later.
- Can I use Robot Virtual Worlds in my classroom?
- Yes, but Robot Virtual Worlds is available via the ROBOTC software.
- How do I register for the course?
- Go to Professional Development Robotics Academy Classes 2013 and follow the instructions.
- Does the Robotics Academy take Purchase Orders?
- Yes.
- When should I register?
- As soon as possible. The courses are limited to 24 students per class and will fill up quickly.
- When are courses offered?
- You can find a list of all classes available here – Professional Development Robotics Academy Classes 2013
All ROBOTC related training is listed below:
Posterboard
Stream 
Month 
Agenda 
Robot Virtual Worlds Google Hangout TONIGHT 6PM!
Hey everyone! Hope you had an awesome weekend. Just a friendly reminder that we’ll be having another fun Robot Virtual Worlds’ Google Hangout at 6pm EST tonight. We will be talking about the gaming environment within RVW and showing off Palm Island, Operation Reset, the Measurement Toolkit, badges, and a lot more! We look forward to having you attend and join in on the discussion! Visit http://ROBOTC.net/hangouts to join us and watch the live video stream.
P.S. Robot Virtual Worlds website has been revamped and is now live! Check it out at http://www.robotvirtualworlds.com
New Time for RVW Google Hangout Today! 6pm EST!
Hey everyone! Just wanted to let you know we are changing the time for today’s Google Hangout webinar to 6pm EST. We will be talking about the Robot Virtual Worlds’ Level Builder and Model Importer! We hope you’re able to attend and join in on the discussion! Visit http://ROBOTC.net/hangouts to join us and watch the live video stream.
Webinar – Using the RVW Curriculum Companion
We will be LIVE at 4pm EST today with our free Robot Virtual Worlds webinar! This is the second in a five part Google + Hangout series that will take place every Monday in the month of April. Today’s topic is how to use the Robot Virtual World’s Curriculum Companion.
If you can’t tune in at 4pm EST, we will update this post later in the day with the YouTube recording. If you are joining us live, make sure to send us your questions …
Video feed:
Check out future webinar dates below:
Webinar – What is Robot Virtual Worlds?
We will be LIVE at 4pm EST today talking about Robot Virtual Worlds. This is the first in a five part Google + Hangout webinar series that will take place every Monday in the month of April. You can watch the live broadcast at 4pm EST, but if you can’t tune in during that time, the video below will turn into a YouTube recording after the event. If you are joining us live, make sure to send us your questions …
Video Feed:
Check out future webinar dates below:
Become a Robotics Academy Certified Instructor
We are extremely excited to announce our new teacher certification courses! A “Robotics Academy Certified Instructor” is officially certified by Carnegie Mellon’s Robotics Academy. The certification will provide an official and public recognition of your competencies and capabilities to teach, program, and troubleshoot educational robots. Check out our most recent video that gives you some more details …
Contact training@rec.ri.cmu.edu to learn more!
- What is the certification?
- The certification is proof from a robotics education world leader that you know how to program and troubleshoot robots.
- Does this course offer college credit?
- The course offers continuing education credit and documents that you have participated in 36 hours worth of instruction at Carnegie Mellon’s Robotics Academy. It is not a college credit course.
- What happens if I don’t pass the certification test?
- The certification test is offered after you complete the course. If you don’t pass the certification test, you will have the opportunity to retake the exam one month later.
- Can I use Robot Virtual Worlds in my classroom?
- Yes, but Robot Virtual Worlds is currently only available for ROBOTC software.
- How do I register for the course?
- Go to Professional Development Robotics Academy Classes 2013 and follow the instructions.
- Does the Robotics Academy take Purchase Orders?
- Yes.
- When should I register?
- As soon as possible. The courses are limited to 24 students per class and will fill up quickly.
- When are courses offered?
- You can find a list of all classes available here – Professional Development Robotics Academy Classes 2013
All ROBOTC related training is listed below:
FREE Robot Virtual Worlds Webinars on Google Hangouts
We understand the challenges robotics classrooms face every day in terms of cost, number of robots, batteries, and homework. That is why we created Robot Virtual Worlds (RVW). With RVW, every student can experience the same benefits of learning robots, right on their computer. RVW currently simulates popular real-world VEX, LEGO, and TETRIX robots in a 3D environment; while using the same language, ROBOTC, to program both your virtual robot and your physical robot.
To help you get started and get a better understanding of what RVW can do, we are offering five FREE webinars on Google Hangout every Monday in April at 4pm EST with project manager, Jesse Flot, and some members of his team! We will show you a brief tutorial on the specific topic of the day then take a few questions from the Google Hangout chat or on twitter using hashtag #RVWHangout.
At each webinar, we will be giving out a discount code for Robomatter, the robotics education store, and a chance to win a one-year license for ROBOTC 3.6!!! To tune in live, follow Robomatter on Google+ or visit ROBOTC.net/hangouts the day of the event (you will need a google+ account or twitter account to submit questions.)
Listed below are the specific dates with topics that we will be covering …
Student Shows Off ROBOTC Skills in Tutorial
When it comes to setting up any new robot, the age-old saying ‘knowledge is power’ tends to ring particularly true. This is why one can find a variety of beginner guides already available, such as the Video Curriculum Trainer and the ‘Getting Started with NXT and TETRIX’ ROBOTC wiki guide. There’s no such thing as too much knowledge, though, and the more tools a roboticist has at their fingertips the higher their chance for success.
Because of this, we are pleasantly surprised by the depth of content covered by Avi, aka TheProgreammerDude’s YouTube tutorial video. Avi is a member of FTC team 5773. Not only is his tutorial straight from the screen of an FTC team programmer, it focuses on ROBOTC programming concepts specifically for the FTC competition (such as using competition templates and setting up a TETRIX robot using the Motors and Sensors Setup window).
If you’re looking add this video set to your ROBOTC toolkit, be sure to check out the first video in his series.
Have you created a ROBOTC or Robot Virtual Worlds tutorial? If so, let us know!
ROBOTC Advanced Training
The ROBOTC curriculum covers quite a bit of material ranging from basic movement to automatic thresholds and advanced remote control. This is plenty of material for the average robotics class. However, it is not enough for some ambitious teachers and students who have mastered the basics. For those individuals who strive to learn the ins and outs of ROBOTC, we offered a pilot course called “ROBOTC Advanced Training” in late July.
The focus of the class is on advanced programming concepts with ROBOTC. Trainees learn to make use of the NXT’s processing power and third-party sensors which expand its capabilities. The class began with a review of the basic ROBOTC curriculum. It then moved into arrays, multi-tasking, custom user interfaces using the NXT LCD screen and buttons, and file input/output. The class worked together to write a custom I²C sensor driver for the Mindsensors Acceleration sensor seen here. Mindsensors Acceleration Sensor
The capstone project for the course involves autonomous navigation on a grid world. The program allows the NXT to find the most efficient path to its goal while avoiding obstacles. The class learned the concept of a “wavefront algorithm”, which enabled autonomous path planning in a world delineated by a grid field. The algorithm assumes that the robot will only use three movements: forward for one block, right turn and left turn. Based on these assumptions, each grid block has four neighbors. They are north, south, east and west of the current block.
The grid world (for our project it was a 10×5 grid) is represented in ROBOTC by a 2-Dimensional array of integers. Integer representations are as follows: robot = 99, goal = 2, obstacle = 1, empty space = 0. The wavefront begins at the goal and propagates outwards until all positions have a value other than zero. Each empty space neighbor of the goal is assigned a value of 3. Each empty space neighbor of the 3’s is assigned a value of 4. This pattern continues until there are no more empty spaces on the map. The robot then follows the most efficient path by moving to its neighbor with the lowest value until it reaches the goal.
It is very exciting to see autonomous path planning implemented in ROBOTC because this is similar to the way full scale autonomous vehicles work. Check out the video of the path planning in action and the full ROBOTC code below. Our future plans are to incorporate these lessons into a new curriculum including multi-robot communications. If this seems like the type of project you would like to bring to your classroom, check back throughout the year for updates and also in the spring for availability for next summer’s ROBOTC Advanced Class.
Written by: Steve Comer
Code for the first run of the program seen in the video:
Note that the only difference in the code for the second program is another obstacle in the 2D integer array.
//GLOBAL VARIABLES grid world dimensions
const int x_size = 10;
const int y_size = 5;
//GLOBAL ARRAY representation of grid world using a 2-Dimensional array
//0 = open space
//1 = barrier
//2 = goal
//99 = robot
int map[x_size][y_size] =
{{0,0,0,0,0},
{0,1,99,1,0},
{0,1,1,1,0},
{0,0,0,0,0},
{0,0,0,0,0},
{0,0,0,0,0},
{0,0,0,0,0},
{0,0,2,0,0},
{0,0,0,0,0},
{0,0,0,0,0}};
//FUNCTION move forward for a variable number of grid blocks
void moveForward(int blocks)
{
//convert number of blocks to encoder counts
//wheel circumference = 17.6 cm
//one block = 23.7 cm
int countsToTravel = (23.7/17.6)*(360)*blocks;
//encoder target for countsToTravel
nMotorEncoder[motorB] = 0;
nMotorEncoder[motorC] = 0;
nMotorEncoderTarget[motorB] = countsToTravel;
nMotorEncoderTarget[motorC] = countsToTravel;
motor[motorB] = 50;
motor[motorC] = 50;
while(nMotorRunState[motorB] != runStateIdle && nMotorRunState[motorC] != runStateIdle) {}
//stop for half second at end of movement
motor[motorB] = 0;
motor[motorC] = 0;
wait1Msec(500);
}
//FUNCTION left point turn 90 degrees
void turnLeft90()
{
//distance one wheel must travel for 90 degree point turn = 10.68 cm
//wheel circumference = 17.6 cm
int countsToTravel = (8.6/17.6)*(360);
//encoder target for countsToTravel
nMotorEncoder[motorB] = 0;
nMotorEncoder[motorC] = 0;
nMotorEncoderTarget[motorB] = countsToTravel;
nMotorEncoderTarget[motorC] = countsToTravel;
motor[motorB] = 50;
motor[motorC] = -50;
while(nMotorRunState[motorB] != runStateIdle && nMotorRunState[motorC] != runStateIdle) {}
//stop for half second at end of movement
motor[motorB] = 0;
motor[motorC] = 0;
wait1Msec(500);
}
//FUNCTION right point turn 90 degrees
void turnRight90()
{
//distance one wheel must travel for 90 degree point turn = 10.68 cm
//wheel circumference = 17.6 cm
int countsToTravel = (8.6/17.6)*(360);
//encoder target for countsToTravel
nMotorEncoder[motorB] = 0;
nMotorEncoder[motorC] = 0;
nMotorEncoderTarget[motorB] = countsToTravel;
nMotorEncoderTarget[motorC] = countsToTravel;
motor[motorB] = -50;
motor[motorC] = 50;
while(nMotorRunState[motorB] != runStateIdle && nMotorRunState[motorC] != runStateIdle) {}
//stop for half second at end of movement
motor[motorB] = 0;
motor[motorC] = 0;
wait1Msec(500);
}
//FUNCTION print wavefront map to NXT screen
void PrintWavefrontMap()
{
int printLine = y_size-1;
for(int y = 0; y < y_size; y++)
{
string printRow = "";
for(int x=0; x < x_size; x++)
{
if(map[x][y] == 99)
printRow = printRow + "R ";
else if(map[x][y] == 2)
printRow = printRow + "G ";
else if(map[x][y] == 1)
printRow = printRow + "X ";
else if(map[x][y] < 10)
printRow = printRow + map[x][y] + " ";
else if(map[x][y] == '*')
printRow = printRow + "* ";
else
printRow = printRow + map[x][y];
}
nxtDisplayString(printLine, printRow);
printLine--;
}
}
//FUNCTION wavefront algorithm to find most efficient path to goal
void WavefrontSearch()
{
int goal_x, goal_y;
bool foundWave = true;
int currentWave = 2; //Looking for goal first
while(foundWave == true)
{
foundWave = false;
for(int y=0; y < y_size; y++)
{
for(int x=0; x < x_size; x++)
{
if(map[x][y] == currentWave)
{
foundWave = true;
goal_x = x;
goal_y = y;
if(goal_x > 0) //This code checks the array bounds heading WEST
if(map[goal_x-1][goal_y] == 0) //This code checks the WEST direction
map[goal_x-1][goal_y] = currentWave + 1;
if(goal_x < (x_size - 1)) //This code checks the array bounds heading EAST
if(map[goal_x+1][goal_y] == 0)//This code checks the EAST direction
map[goal_x+1][goal_y] = currentWave + 1;
if(goal_y > 0)//This code checks the array bounds heading SOUTH
if(map[goal_x][goal_y-1] == 0) //This code checks the SOUTH direction
map[goal_x][goal_y-1] = currentWave + 1;
if(goal_y < (y_size - 1))//This code checks the array bounds heading NORTH
if(map[goal_x][goal_y+1] == 0) //This code checks the NORTH direction
map[goal_x][goal_y+1] = currentWave + 1;
}
}
}
currentWave++;
PrintWavefrontMap();
wait1Msec(500);
}
}
//FUNCTION follow most efficient path to goal
//and update screen map as robot moves
void NavigateToGoal()
{
//Store our Robots Current Position
int robot_x, robot_y;
//First - Find Goal and Target Locations
for(int x=0; x < x_size; x++)
{
for(int y=0; y < y_size; y++)
{
if(map[x][y] == 99)
{
robot_x = x;
robot_y = y;
}
}
}
//Found Goal and Target, start deciding our next path
int current_x = robot_x;
int current_y = robot_y;
int current_facing = 0;
int next_Direction = 0;
int current_low = 99;
while(current_low > 2)
{
current_low = 99; //Every time, reset to highest number (robot)
next_Direction = current_facing;
int Next_X = 0;
int Next_Y = 0;
//Check Array Bounds West
if(current_x > 0)
if(map[current_x-1][current_y] < current_low && map[current_x-1][current_y] != 1) //Is current space occupied?
{
current_low = map[current_x-1][current_y]; //Set next number
next_Direction = 3; //Set Next Direction as West
Next_X = current_x-1;
Next_Y = current_y;
}
//Check Array Bounds East
if(current_x < (x_size -1))
if(map[current_x+1][current_y] < current_low && map[current_x+1][current_y] != 1) //Is current space occupied?
{
current_low = map[current_x+1][current_y]; //Set next number
next_Direction = 1; //Set Next Direction as East
Next_X = current_x+1;
Next_Y = current_y;
}
//Check Array Bounds South
if(current_y > 0)
if(map[current_x][current_y-1] < current_low && map[current_x][current_y-1] != 1)
{
current_low = map[current_x][current_y-1]; //Set next number
next_Direction = 2; //Set Next Direction as South
Next_X = current_x;
Next_Y = current_y-1;
}
//Check Array Bounds North
if(current_y < (y_size - 1))
if(map[current_x][current_y+1] < current_low && map[current_x][current_y+1] != 1) //Is current space occupied?
{
current_low = map[current_x][current_y+1]; //Set next number
next_Direction = 0; //Set Next Direction as North
Next_X = current_x;
Next_Y = current_y+1;
}
//Okay - We know the number we're heading for, the direction and the coordinates.
current_x = Next_X;
current_y = Next_Y;
map[current_x][current_y] = '*';
//Track the robot's heading
while(current_facing != next_Direction)
{
if (current_facing > next_Direction)
{
turnLeft90();
current_facing--;
}
else if(current_facing < next_Direction)
{
turnRight90();
current_facing++;
}
}
moveForward(1);
PrintWavefrontMap();
wait1Msec(500);
}
}
task main()
{
WavefrontSearch(); //Build map of route with wavefront algorithm
NavigateToGoal(); //Follow most efficient path to goal
wait1Msec(5000); //Leave time to view the LCD screen
}
2011 Summer Online Training schedule available!
The Robotics Academy has just released the Summer Online Training schedule for 2011. Take a look below for the dates:
- ROBOTC for LEGO / TETRIX
- July 11th-15th, 2011 (Monday-Friday for 1 Week)
- 10:00am-12:00pm EST (7:00am-9:00am PST)
- Register by June 27th, 2011
- CLICK HERE TO REGISTER for ROBOTC for LEGO / TETRIX
- ROBOTC for VEX PIC and CORTEX
- August 8th-12th, 2011 (Monday-Friday for 1 Week)
- 3:30pm-5:30pm EST (12:30pm-2:30pm PST)
- Register by July 25th, 2011
- CLICK HERE TO REGISTER for ROBOTC for VEX PIC and CORTEX
For questions about payment, please email customerservice@robomatter.com.
For questions relating to training, please email training@rec.ri.cmu.edu, or you can comment on this post below.
