ROBOTC.net Blog  

We want to thank everyone who has been using our Robot Virtual World software and providing valuable feedback. Just so you know we’re listening, here are some of the major improvements that will be coming soon!

We had to do an overhaul of our infrastructure, but our VEX Sack Attack and FTC Ring it Up competition tables now support encoders on each joint! Here’s a screenshot of the Sensor and Motor Debug windows – look at all those inputs and outputs!

FTC Ring it Up!
Every NXT and TETRIX Motor on the robots is now equipped with an encoder. Due to several requests, we’ve also replaced the Compass Sensor with a Gyroscope! (Click the picture to enlarge)

VEX Sack Attack
Like the Ring it Up table, we’ve added encoders to the “shoulder” motors on Scooperbot and Clawbot. We also added a potentiometer to the scooper on Scooperbot, and Gyroscopes on all three of the robot models! (Click the picture to enlarge)

These are just some of the major improvements we’ve made in the competition tables. We’ve made lots of other great ones that you’ll just have to wait to see.

Keep an eye on our blog for their public availability, scheduled for the very beginning of November.

This is the first in a series of posts that will explain the new functionality behind the latest ROBOTC update. Beginning with ROBOTC 3.5 with all of the new functionality towards becoming an ANSI-C compliant language has brought some changes that may confuse veteran ROBOTC users. This week we’ll take a look at how global and local variables work in ROBOTC.

In previous ROBOTC releases, the compiler (the engine that converts your code from C-language to machine language) would treat all variables as “Global Variables” and would allocate (assign memory to) every variable when the program was compiled. This method caused issues because it would not allow the compiler to understand re-entrant functions (i.e. functions that could call themselves). This functionality was limiting because it prevent a key computer science concept called “Recursion” which is the ability to have a function call itself repeatedly (but not infinitely). Recursion is very useful when dealing with sorting data or calculating a series of data in different algorithms (one example: calculating a Factorial value – 5! = 5*4*3*2*1)

Example of Recursion: Calculating a Factorial Value

In ROBOTC 3.5, the compiler’s functionality has been extended in order to support recursive functions by supporting the concept of “Call Stack” variables. The idea of the Call Stack is that ROBOTC will now store local variables and return addresses of functions onto a Call Stack – This unlocks the ability to have recursive functions and variables that are truly “local”. With the Call Stack, ROBOTC is able to keep track of multiple calls of the same function and coordinate all of the variables so there’s no accidental overwriting of data or multiple copies of the same variables to keep track of – Everything automatically done by the compiler when the program is run!

A visual look at a “Call Stack” (from Wikipedia)

With the call stack, ROBOTC’s firmware assigns the memory address of local variables when they’re declared in the code (as opposed to compile time as before). Variables are allocated and discarded on the stack as needed – users do not need to modify their code to take advantage of this functionality. Programs do still need to specify a variable’s type and size ahead of time however. (i.e. no dynamically sized arrays)

Three different ways to allocate variables.

There is one big difference when it comes to debugging – users will see the old “Variables” display is now split between “Global” and “Local” variables in the ROBOTC Debugger. Because the ROBOTC IDE doesn’t know where the variable will be stored in the “call stack”, there’s no way to accurately know where the local variables are on the stack at any one time. What this means is that you will not be able to view your local variables during run-time like in previous versions of ROBOTC. This is a limitation of professional IDEs (Visual Studio, Eclipse, AVR Studio) that also support recursion and variable stacks. The new extended ANSI-C functionality brings ROBOTC close to the same level as those development environments including the same limitations when debugging.

Hey where are all of my variables?

The good news is that users have two options for debugging their program’s variables:

1. Suspend your program by using the “Step” button– When the program execution is suspended, the IDE is able to display all of the current local variables for the current function/task selected. This will not display every local variable in your program, but only the currently executing function/task.
   

   When the program is suspended, ROBOTC can load the “Call Stack” and display Local Variables accurately.

2. Use Global Variables– Because Global Variables are allocated at compile time, the ROBOTC IDE knows the memory location of every Global Variable and can keep track of these variables in the “Global Variables” debugger window. All Global Variables will be continuously updated as the program is executed.
   

   With Global Variables, ROBOTC know the address of the Variable at all times, so it is able to always display the value.

We understand some of the frustration that ROBOTC users are experience with the new ROBOTC 3.5 update with all of the new functionality, and we apologize for any issues. Our overall objective is to make ROBOTC as close to a true ANSI-C programming environment to make sure students and users are learning proper coding techniques.

As we continue to refine our implementation with the latest version of ROBOTC, we still are committed to addressing any reported issues and would love to hear from you if you are having any problems – Please send us a note using our Ticketing system at http://www.robotc.net/support/ or directly at support@robotc.net.

In February 2011, the Robotics Academy released our first version of Robot Virtual Worlds (RVW). Back then, we were striving to make a new educational breakthrough that would allow kids using the motivational effects of video games and robotics combined to learn all about programming. Users are able to program virtual robots using the exact same programming language that they used to control their real robots – they could work with a robot at school and then go home to continue their education using our unique simulation engine!

Since that initial release, we have learned an incredible amount about robot simulations, game development, and our customer’s expectations and desires. Since our initial beta release in February and our retail release in September of 2011, we have made great improvements that provide a much richer overall experience. Some of these new features include:

• Improved Robot Physics and Gameplay
• New and Improved Sensor Simulation
• Completely new robot models with new features such as gripper arms and elevator lifts.
• More “game” like worlds with real-time scoring and open ended challenge
• CS2N.org integration for earning achievements and badges
• Education tools like user tracking (via CS2N) to keep tabs on student progress

Today we’re announcing an extended free trial opportunity for everyone to try our latest Robot Virtual Worlds software until the end of the year. This extended trial is available to everyone, including those users who have already used their initial 60-day trial included with the Robot Virtual Worlds software. This extended trial will allow you to try Robot Virtual Worlds until the end of 2012. Our hope is that you’ll give our updated worlds a test drive and see the incredible improvements we’ve already made and continue to make every day. To find out how to download your free extended license, take a look below.

Steps for NXT Users to use the FREE license:

1. Install/Update to the latest version of ROBOTC (Currently 3.51) http://www.robotc.net/download/nxt/
2. Download the special extended LEGO trial license. This file will allow the Virtual Worlds to work until December 31, 2012 and can be installed on an unlimited number of computers at school or at a student’s home. This license WILL work even if your ROBOTC trial is already expired http://www.robotc.net/files/RobotVirtualWorlds_LEGO_InstallLicense.exe
3. Make sure ROBOTC is closed and run the installer for the extended trial license. This installer will automatically install and activate the extended trial.
4. To learn how to access the RVW once they are installed go to: http://www.robotc.net/download/rvw/step2a-setting-up-rvw.php

Steps for VEX Users to use the FREE license:

1. Install/Update to the latest version of ROBOTC (Currently 3.51) http://www.robotc.net/download/cortex/
2. Download the special extended VEX trial license. This file will allow the Virtual Worlds to work until December 31, 2012 and can be installed on an unlimited number of computers at school or at a student’s home. This license WILL work even if your ROBOTC trial is already expired. http://www.robotc.net/files/RobotVirtualWorlds_VEX_InstallLicense.exe
3. Make sure ROBOTC is closed and run the installer for the extended trial license. This installer will automatically install and activate the extended trial.
4. To learn how to access the RVW once they are installed go to: http://www.robotc.net/download/rvw/step2a-setting-up-rvw.php

The Curriculum Companion is designed for computer science and robotics classes. This product includes over 30 tabletop type classroom activities that mirror the activities found in the ROBOTC for MINDSTORM and ROBOTC for VEX Curriculums. Students can pick from several robot types. Students earn badges as they complete the RVW challenges that can lead to them earning a Robotics Academy Robotics Programming Certification.

The LEVEL Builder allows students and teachers to design their own levels. This initial product gives the level designer a 12’ by 12’ pallet to design on and uses existing models found in the curriculum companion. By this spring, students will be able to import their own models using standard modeling software. Eventually, our goal is to enable students to build their own robots and import them into RVWs!

Palm Island is a fantasy world where students can practice basic behavior based programming. This world is simple but interesting. The first level involves moving straight, second level turning, third level combining straight and turning… The world is designed so that students can practice simple behaviors to complete the challenge. Students should complete lessons in the movement section of the curriculum before they attempt Palm Island.

RING IT UP simulates this year’s FTC game. Ring It Up provides a game-like environment where students program TETRIX robots to solve game. The game keeps track of time and as your students play the game their scores are tracked. Students can program the robot’s wheels, arm, elbow, and gripper. The game simulation also features an automatically configured IR beacon so that students can test their IR beacon code.

SACK ATTACK simulates this year’s VEX Robot Game. Sack Attack provides a game-like environment where students program VEX robots to solve game. The RVW simulation keeps track of time and score as the robot competes in the game. The new game allows programmer to program the robot’s wheels, arm, elbow, and gripper. The game simulation also allows remote control.

Ruins of Atlantis is an underwater world where students can practice basic behavior based programming. Students collect jewels and coins in this game as they work through an underwater maze. The game includes our first underwater robot! Students should understand basic ROBOTC programming before they attempt to solve the game.

Operation Reset! We will release the third edition of Operation Reset in October of 2012. This is the most game-like world we’ve ever released. Students are required to program or remotely control robots on Planet H99. The colony was just hit by an intergalactic storm and all of the satellite communication towers need reset. The robots are also tasked to collect unobtanium, refuel a rocket, and solve a variety of unanticipated events.

The project that you’ve all been waiting for is here at last! We are thrilled to announce that our first version of the Robot Virtual World Level Builder is now available. Configure your own levels out of a wide selection of classroom-themed assets: balls, cylinders, boxes, walls, line tracking tiles, and more. Challenge yourself, or share your levels with students, classmates, or teammates. It’s a free download for all ROBOTC for RVW users, so what are you waiting for?

Once you have the Level Builder installed, you can launch it within ROBOTC by going to Window > Open RVW Level Builder Utility. (Note that you must have ROBOTC 3.50 or newer installed, and that Virtual Worlds must be selected as your Platform Type.)

The Level Builder will appear with two options: CREATE and PLAY.

• Use CREATE to configure your own virtual world level out of classroom themed assets.
• Use PLAY to program a virtual robot to complete a level generated in CREATE mode.

In CREATE mode, you’re presented with a blank 12′x12′ table just waiting for you to fill it with objects.

• Drag-and-drop cubes, cylinders, balls, walls, and line tracking tiles onto the table to configure your level.
• Use the PROPERTIES panel to adjust the orientation of the objects.
• Zoom in and out on the table using the slider in the bottom right.
• Your virtual robot will always start on the START tile, facing out.
• Be creative!!!

Once you’ve configured the table to your heart’s content, save it, and press PLAY.

From there, you’ll be brought to the Level and Robot selection screen.

• SELECT LEVEL will automatically be populated with the table that you just configured.
• Additional demo levels are included in the download.
• Choose from several available robots, each with their details listed on the screen.
• Press START LEVEL to load your level with the currently selected robot.

Your level will load with the robot that you selected.

• Compile and Download ROBOTC code to solve the challenge.
• Switch quickly between BUILD MODE and LEVEL SELECTION as you create your perfect level.
• USE the “WASD” keys to easily check out the level before writing code or passing it on to your students or fellow classmates.

More instructions, details, and videos are coming soon! We would love to hear what you think of the Level Builder, so let us know! Any feedback and suggestions are welcome. Most of all, have fun!

Need help getting up and running with ROBOTC for RVW? Check here for setup instructions. Not already a ROBOTC for RVW user? Download a free 60-day trial right now.

Attention all VEX teams! We just released a substantial update to this year’s VEX Sack Attack virtual world. Download it here, or on the RVW Level Packs download page. Here’s what’s new:

New Robot: Clawbot

• Clawbot features a 4-wheel, 2-motor drive system, an arm motor, a gripper, and the full array of sensors. Best of all, it’s fully programmable in ROBOTC!
• Additional sample code for Clawbot is installed with the update, and can be downloaded here.

Pre-loads and Automatic Scoring

• Both Gripperbot and Scooperbot can be pre-loaded with a sack! You can control what side the robot starts on, whether it gets a pre-load, and enable the autonomous duration all from the main menu.
• Scoring is fully implemented in this new version.
  • Earn normal points from sacks, bonus points from bonus sacks, and even more bonus points from the autonomous bonus and “parking” your robot before time runs out.
  • A cool, new timer and scoreboard keeps track of the match in the top-left corner of the window. Compete with your classmates or teammates to see who can get the highest score before time runs out!
• Driver Control loads are also implemented once the autonomous period ends. Introduce them into the playing field by clicking on the green sack icons in the top-right corner.

Sensor View

• Ever wonder why your Ultrasonic sensor “sees” the values that it does? Enable the new Sensor View to see what’s triggering the Ultrasonic sensor and the heading of your compass.

Additional Enhancements

• We’ve improved the robot-sack interaction on all of the robots.
• The lighting and contrast of the game have been enhanced, making it easier to grab and score the sacks.
• Lots of small tweaks and adjustments.

To view the original post for the VEX Sack Attack virtual world (complete with video), visit this link.

The ROBOTC Development team is proud to announce that ROBOTC 3.50 for the LEGO Mindstorms, VEX Cortex and PIC, Arduino, and Robot Virtual World platforms is now available! The new ROBOTC 3.50 update is free-of-charge for ALL existing ROBOTC 3.0 license holders. Download today and try out all of the new features and enhancements available in ROBOTC 3.50!

Change log for ROBOTC 3.50 (since version 3.08):

MAJOR UPDATES:

• Full ANSI-C support to support pointers, recursion, and stacks with an updated compiler and updated robot firmware.
• New and Updated Debugger Windows:
  • “Local Variables” to monitor variables in the current task or function.
  • (Note: Local variables are only available when your program is suspended)
  • “Global Variables” to monitor variables available to your entire program.
  • “Call Stacks” to monitor function calls in the currently selected task.
• Updated Documentation and Wiki (www.robotc.net/wiki) – Constantly Updating!
• Support for Standard C commands – sprintf(), sscanf(), support for character arrays, unsigned variables, etc.
• Support for the Arduino family of controllers (Uno, Mega, Mega 2560) with future support and expanded functionality for the Arduino Leonardo and Due controllers.
• Updated Robot Virtual Worlds support to include additional sensors and motors.
• Improved Robot Virtual Worlds performance to simulate more realistic physics and robot behaviors.
• Support for the new MATRIX building system with the NXT.

Robot Specific Fixes:

• NXT I2C sensors were incorrectly initializing clock and data lines as outputs when first configuration. They were correctly left as inputs after first message was sent. Change was to initialize as inputs. Before change, the first I2C message on an empty port will incorrectly appear to succeed.
• Ignore HiTechnic Textrix Motor Controller spurious encoder counts. I.E. if encoder value read is hex ‘FF80xxxx’ then force a reread. Always accept the re-read value.
• Eliminate Z-Axis from VEX joystick window as is unused.
• Arduino boards now support controlling LEDs from PWM pins.
• Arduino boards now will read zero when connecting analog to ground.

Interface Updates/Fixes:

• Add “Show Current Program Counter” button to Debugger.
• Add new template for “New File”. All new programs will start with a task main structure. This template can be modified by the user (it lives in  /Sample Programs/Platform/Templates)
• Always force “Save As” for all template files. Before the files were being saved in a default directory.
• Allow any serial port to be used with VEX PIC systems.
• Allow user entered blank (empty) lines before first “#pragma config(” lines. Currently generates a compiler error.
• Improve placement of related compiler generated errors to appropriate line numbers.
• Fix bug where “Motors and Sensors Setup” did not work on empty files.
• Properly restore floating “Debugger Panes” when Debugger is invoked.
• Changed Checkmarks to Radio Icons for many menu items. This shows a “dot” instead of a “check mark” in the menu icon field.
• Created tooltip strings in resource file for all missing commands.
• Prepare to add two new Debugger panes to display “Breakpoints” and “Bookmarks”. Based on the existing “Compiler Errors” pane architecture. The new panes are displayed but the content is still empty.
• Better synchronization of breakpoints between “Source File” and “Disassembly Listing”. Previously when breakpoint was added/removed in one window the corresponding change was not properly made in the other window. Now the breakpoint ICONs are always refreshed whenever a window is “Activated” (i.e. made topmost).
• Add two new menu commands for “increase indent” and “decrease indent”.
• Tweak “auto close breakpoint hit” message box implementation. Add a check mark to the dialog.
• Add new “Compile OR Compile+Download” toolbar.
• Debug “Task Status” window — minor enhancements.
• FONT name was not being updated in Preferences “Font” tab correctly. Fixed.

Compiler and Command Updates/Fixes:

• Pointer support. New functions positioning for improvements in the dereference (“*”) and address of (“&”) unary operators.
• New “#pragma debugWindows(…)” to specify a list of Debugger Windows that should be opened.
• Add new intrinsic function “DebugStreamClear” to allow programs on robot to clear the debug stream.
• Support for “Implied Pointers” in functions.
• Fixed compiler priority for binary and unary versions of ‘&’, ‘*’, ‘+’ and ‘-’ operators.
• Support for unsigned longs.
• Add new intrinsic function for “round”.
• Added support for ‘atan2′.
• Allow ‘struct’ pointers as valid function return types.
• Fix issue in ‘struct’ declaration causing a random memory overwrite in ROBOTC IDE.
• Support pointer variables for ‘++’ and ‘–’.
• ‘sizeof’ operator now accepts argument types of ‘char’, ‘short’, ‘long’, ‘float’, …
• Fix bug in evaluating “complicated” / compound constant expressions in “#if”.
• Add support for ‘%p’ format code in ‘sprintf’.
• Improve code generation for pointer references to ‘struct’.
• Added doubly nested ‘->’ operator.
• Fixed bug in unary ‘-’ VM opcode.
• Improve code generation for structure element access.
• Fix implementation of structure element access code generation; i.e. the “.” operator.
• Partially re-implement “sizeof” operator for proper calculation of ‘pointer’ and ‘reference’ variables.
• Add “drop down toolbar button” to “Compile and Download” toolbar to select “Download + Compile” or “Compile” only; vs two separate buttons.
• Add partial support for new download “write to RAM” message. Needed for new “local variables” window.
• Add support for new “trinary opcodes” (+, – and *) with ‘long’ operands. Previously trinary opcodes were for ‘short’ variables. Trinary opcodes are primarily used for efficient code generation for array and structure element access.
• Added definition for new “NoOp” command.

We’re always happy to see ‘outside-the-box’ robotics inventions, so when we were contacted by a local high school teacher  (Dana Clay from Baldwin-Whitehall School District) with a couple of youtube videos, we were more than curious to see what his class had cooked up. We were not let down. The first video shows a VEX contraption that shoots ping-pong balls through a pipe “hoop” with surprising accuracy. It even has a degree of human interaction; the light sensor can be covered/uncovered to control how far the attached arm rotates.

YouTube Direct Link 

The second video is a very cool movie of a VEX-built robot typing “I LOVE ROBOTS” on a keyboard. Robots controlling computers; now that’s an awesome idea!

YouTube Direct Link 

The final video is of a looped track with a VEX tank tread/catapult combo providing the upwards momentum to keep things rolling smoothly. This is the Ball That Never Stops, people, and it has a catapult; how can you not love it? All three were programmed in ROBOTC, of course. Enjoy!

YouTube Direct Link 

The ROBOTC Development team is proud to announce thatROBOTC 3.5 for the LEGO Mindstorms, VEX Cortex and PIC, Arduino, and Robot Virtual World platforms will be available on September 7^th, 2012. The new ROBOTC 3.5 update will be free-of-charge for ALL existing ROBOTC 3.0 license holders. Download a Beta version (3.45) today to get a sneak peak at all of the new features and enhancements available in ROBOTC 3.5!

ROBOTC 3.5 has a number of new features and enhancements:

• Full ANSI-C support to support pointers, recursion, and stacks with an updated compiler and updated robot firmware.
• New and Updated Debugger Windows:
  • “Local Variables” to monitor variables in the current task or function.
    (Note: Local variables are only available when your program is suspended)
  • “Global Variables” to monitor variables available to your entire program.
  • “Call Stacks” to monitor function calls in the currently selected task.
• Updated Documentation and Wiki (www.robotc.net/wiki) – Still in progress!
• Support for Standard C commands – sprintf(), sscanf(), support for character arrays, unsigned variables, etc.
• Support for the Arduino family of controllers (Uno, Mega, Mega 2560) with future support and expanded functionality for the Arduino Leonardo and Due controllers.
• Updated Robot Virtual Worlds support to include additional sensors and motors.
• Improved Robot Virtual Worlds performance to simulate more realistic physics and robot behaviors.
• Support for the new MATRIX building system with the NXT.
• Many general enhancements and bug fixes – more in-depth change log to come with the ROBOTC 3.5 official release.

Please remember that the Beta available today should not be installed across entire school sites–this is a beta version, so install at your own risk!

You can participate in the ROBOTC 3.45 Beta version by downloading a copy here. Please note that the Beta version will uninstall your existing version of ROBOTC; the Beta will use your existing licensing so there is no need to ‘Deactivate’ before installing. If you have any issues/questions with the ROBOTC Beta, please e-mail betasupport [at] robotc [dot] net for assistance and to alert us of any issues to be fixed between now and release day.

The Robot Virtual World team is proud to announce their initial release of the VEX Sack Attack virtual environment! This years competition field features a higher level of interactivity and simulation than ever before. Several new robots (with expanded motors and sensors) designed specifically for Sack Attack have been added to the line-up, and are fully programmable through ROBOTC.

Note that the new features in the virtual world also require that you have the latest Beta version of ROBOTC installed, which is available here.

Here’s a video of the Sack Attack virtual world in action:

New Robots
Check out Scooperbot scoring Sacks and Bonus Sacks in the Trough and High Goal:

And Plowbot pushing Sack and Bonus Sacks into the Floor Goals:

User Interface
The new and improved user interface allows you to switch between the robots, and tells you where the growing list of motors and sensors are connected:

Controlling the Robots
Sample code for programming the robots to move autonomously or via a Logitech USB Remote control can be downloaded here: Sack_Attack_Sample_Code.

Don’t have a Logitech USB Remote Control? No Problem! We’ve also added keyboard control for the robots when a ROBOTC program isn’t running! The controls are as follows:

• “W” key: Robot moves forward
• “A” key: Robot turns left
• “S” key: Robot moves in reverse
• “D” key: Robot turns right
• “{” key: Scooper motor up
• “}” key: Scooper motor down
• “<” key: Arm motor up
• “>” key: Arm Motor down

Future Enhancements!
We’re extremely excited about this release, but we’re not done yet. Check out some of the enhancements that are on their way!

More robots! Clawbot:

Holobot with claw:

Improved Sack physics, and Robot-to-Sack Interaction:

The VEX Sack Attack virtual world can be downloaded here, or under the Available Level Packs section of the RVW Download Page.

Important! The new features in the virtual world also require that you have the latest version of Beta version of ROBOTC installed, available here. Don’t have ROBOTC for Robot Virtual Worlds? It comes with a free 60-day trial, so download it today. Need help getting it set up? Check out the setup videos, here.

John and Karthik at VEX Robotics have put together a fantastic set of videos for teams competing in the VEX Sack Attack Robotics Competition.

The 9-video series breaks down the rules for the competition, and shows how referees will interpret the different scenarios that may occur. It’s definitely a worthwhile watch for any teams competing this year (or anyone who wants to see John hug this years game object).

You can watch the full video series here, or on their YouTube page: http://www.youtube.com/playlist?list=PLEC832168771665F2