ROBOTC.net Blog  

ROBOTC News

Archive for the ‘Training’ Category

Robotics Summer of Learning

without comments

Robotics Summer of Learning

This summer students have the opportunity to learn how to program robots, design games, animate stories, and earn a chance to win over $10,000 in prizes and scholarships! The Robotics Summer of Learning program hopes to effectively increase students’ interest in STEM (science, technology, engineering, mathematics) related fields. The program is hosted online at the Computer Science Student Network.

The Summer of Learning initiative is sponsored by Carnegie Mellon’s Robotics Academy - an educational outreach of Carnegie Mellon University and a part of the university’s world-renowned Robotics Institute. The Robotics Academy mission is to develop educational tools and resources to use the motivational effects of robotics to excite students and teachers about science and technology.

The Computer Science Student Network (CS2N) is a collaborative research project between Carnegie Mellon University (including the Robotics Academy) and the Defense Advanced Research Projects Agency (DARPA) designed to increase the number of students pursuing advanced Computer Science and STEM degrees. CS2N is an online network for students and teachers to connect together and use engaging activities designed to teach how to program robots, animations, web pages, and games.

CS2N also includes tools for teachers/educators to create their own individual groups for students to join. Using the “groups” feature, teachers can track their students’ progress through every activity offered on the site. All of CS2N’s learning activities are designed to align with national educational standards.

Check out all the great features and challenges that will be offered through the Robotics Summer of Learning…

Programming Robots 

ROBOTC logoThe Robotics Summer of Learning will offer students the opportunity to program a variety of robots in deep space, on a tropical island, and a VEX or FTC game board. The robots are programmed in ROBOTC, a programming language for LEGO, VEX and Arduino robots. Beginning ROBOTC users are able to utilize simple Natural Language commands like forward, reverse, and pointTurn at the introductory level and then migrate to full C-Programming to learn advanced computer science concepts like recursion, pointers, multitasking/threading, and multi-agent communications.

Students will program the virtual robots using the ROBOTC language and ROBOTC’s Robot Virtual Worlds (RVW) software, an interactive educational video game software that allows every student to experience the same benefits of learning robotics and programming. RVW tracks and stores student’s progress, through CS2N, as they solve different levels in each World. After successfully completing a World, students earn a badge that documents their achievements. At the end of the summer, students will have the opportunity to take an exam that will earn them a Carnegie Mellon Robotics Academy programming certification, which can be included in the student’s academic portfolio.

Introductory programming lessons are taught in the tropical themed Palm Island, one of three virtual environments in Robot Virtual Worlds. Once students learn the basics in their first mission, they are then challenged to complete missions on Planet H99 in deep space, and underwater in the Ruins of Atlantis. The final challenge is a national robot programming competition that will include over ten thousand dollars in scholarships and prizes. Two new “programming only” robotics game have been developed specifically for the Robotics Summer of Learning programming competition, which take advantage of current VEX and FTC games in Robot Virtual Worlds. The games are played by autonomously programming your robot to place objects into scoring positions as quickly as possible.

VEX “Toss Up”

VEX Toss Up

CS2N’s VEX Toss Up challenges you to program your autonomous virtual robot with ROBOTC to score as many points as possible, via scoring or locking BuckeyBalls and large balls, as well as hanging from a colored bar!

FTC “Ring It Up!”

FTC Ring It Up

CS2N’s FTC “Ring It Up!” challenges you to program your autonomous virtual robot with ROBOTC to score as many points as possible, via hanging rings on the center or corner post hangers and placing rings on the red floor tiles!

 

Nature Documentary

Animation

Animation programming languages, such as Scratch and Alice, make it easy for students to create video stories, animations, games, music, and art. By using storytelling and animation as a motivator, students learn the importance of the design process while using and learning interactive programming software.

Our Robotics Summer of Learning Animation Challenge is called Nature Doc-u-mentary. This challenge asks students to write a creative narrative and make an animated documentary using either Scratch, SAM Animation, or Alice 2.0.

 

 

 

Game Design

Beacons and Barriers

Designing a digital game allows students the opportunity to creatively brainstorm ideas, create 3D objects to import into the game board, learn how to program in order to test the success of the game, and challenge them to think of ways to advance and optimize the gameplay. Robot Virtual Worlds comes with two great tools, the Level Builder and the Model Importer. The Level Builder uses a 12-inch by 12-inch board and our “desktop” models to create their very own Robot Virtual World. The Model Importer allows students to import their own 3D models into Level Builder to take their game to the next level. Students can use both tools while designing their own game board for a virtual robot to successfully complete!

Our Robotics Summer of Learning Animation Challenge is called Beacons and Barriers.  This challenge will have users focus on creating levels for a virtual robot to navigate through. They will use the Model Importer, included in Robot Virtual Worlds, to create objects to serve as checkpoints and obstacles.

 

 

The Robotics Summer of Learning Program is excited for the opportunity to advance students’ interests in STEM and advanced their programming skillsets! Software and training will be provided for free throughout the summer. Students will have 24/7 access to the online course materials, as well as professional support from developers of the software and curriculum. There will be over $10,000 in prizes available to participants in the challenges, including free software, robot kits, and college scholarships. The Robotics Summer of Learning kicks off on June 1 and runs to September 1, 2013. 

Sign Up Today for the Robotics Summer of Learning!

 

———————————————————–

 

Professional Development

Also offered during the summer are our Professional Development courses. These courses provide teachers and coaches with a solid foundation for robot programming in the respective languages, and experience in troubleshooting common student mistakes. It also focuses on identifying and extracting academic value from the naturally occurring STEM situations encountered in robotics explorations. Classes are available on-site or online.

Classes are filling up quick, so sign up today!

 

Become a Robotics Academy Certified Instructor

without comments

NXT Student Certification Version Advanced NBWe are extremely excited to announce our new teacher certification courses! A “Robotics Academy Certified Instructor” is officially certified by Carnegie Mellon’s Robotics Academy. Read the rest of this entry »

Written by Cara Friez

March 28th, 2013 at 6:51 pm

FREE Robot Virtual Worlds Webinars

without comments

RVW Webinars RAWe 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 through Google Hangout  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.

 

 

 
 
 
 

 

 
 
 

Listed below are the specific dates and topics we will be covering …

Free Robot Virtual Worlds Webinars on Google Hangouts

Monday, April 1 at 4pm EST
  • What is Robot Virtual Worlds?
    • Overview of RVW.
    • Why RVW?
    • Step-by-step tutorial on getting started.
    • Additional RVW Resources.
Monday, April 8 at 4pm EST
  • Using the RVW Curriculum Companion.
    • Free ROBOTC Curriculum, including programming challenges.
    • Programming challenges, along with the curriculum robots.
    • Solve one of the challenges.
    • Benefits of using RVW in addition to or in place of real robots.
    • Badges with RVW and on CS2N.
Monday, April 15 at 4pm EST
  • Using the RVW Level Builder with Model Importer
    • What is Level Builder and why we made it?
    • Sample level.
    • Program levels using ROBOTC.
    • Share levels with another person.
    • Import an object using the Model Importer and include it in the newly created level.
Monday, April 22 at 4pm EST
  • Gaming Environments with the Robot Virtual Worlds
    • Palm Island and Operation Reset.
    • Benefits of using the game environments.
    • Measurement Toolkit to find distances the robot needs to move.
    • Badges with RVW and on CS2N.
Monday, April 29 at 4pm EST
  • Competition Environments with the Robot Virtual Worlds
    • Why do so many teams wait until the last minute to program their robots?
    • Autonomous and remote control scoring in the environment.
    • Multiplayer features in development.
    • CS2N Programming Competition development.

ROBOTC Advanced Training

without comments

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


YouTube Direct Link 

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
}

Written by Vu Nguyen

August 8th, 2011 at 9:22 am

2011 Summer Online Training schedule available!

without comments

The Robotics Academy has just released the Summer Online Training schedule for 2011. Take a look below for the dates:

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.

Written by Vu Nguyen

March 23rd, 2011 at 2:56 pm