ROBOTC.net Blog  

ROBOTC News

Archive for the ‘Releases’ Category

Update – ROBOTC for VEX Robotics 4.08

with 4 comments

ROBOTC logo 4 UpdateThe ROBOTC Development Team is excited to announce the availability of ROBOTC for VEX Robotics 4.08 – an update for the VEX Cortex and VEX IQ platforms. This new version supports the latest firmware versions provided by VEX Robotics (4.20 for VEX Cortex / 1.09 for VEX IQ) and all of the new features supported by the new firmware updates. Some of these new improvements include:

- Support for the VEXnet 2.0 (white) Radios for the VEX Cortex
- Bug Fixes for the VEX IQ system to prevent “I2C Errors”
- Speed enhancements for VEX IQ for better performance of motors and sensor
- New VEX IQ commands for Gyro sensors

This new version of ROBOTC also supports the VEX IQ “Graphical Natural Language” feature. This new interface allows users to program robots from inside ROBOTC with easy-to-use graphical blocks that can be drag-and-dropped to form a program. Each block represents an individual command from the “text-based” ROBOTC and Natural Language. The new click and drag interface along with the simplified commands of Natural Language allows any robotics user to get up and running with programming their robots as soon as possible. As of today, the Graphical Natural Language commands work with the VEX IQ system, but we’re actively developing support for ALL ROBOTC supported platforms!

Before you can use ROBOTC for VEX Robotics 4.08, you will need to ensure that your VEX devices are up to date. The instructions to update your hardware will be different depending on what hardware setup you may have…

  • VEX IQ Users
    • Run the “VEX IQ Firmware Update Utility” and update your VEX IQ brain to firmware version 1.09. You will also have to install the latest ROBOTC firmware from inside of ROBOTC.
  • VEX Cortex Users (with Black VEXnet 1.0 Keys)
    • You will need to update your VEX Cortex and VEX Game Controllers with version 4.20 from inside of ROBOTC. After updating your master firmware, you will also have to install the latest ROBOTC firmware as well.
  • VEX Cortex Users (with White VEXnet 2.0 Keys)
    • The new VEXnet 2.0 keys have a specific “radio firmware” that you will need to upgrade to enable “Download and Debugging” support. You can find this utility here.
    • Download the “VEXnet Key 2.0 Firmware Upgrade Utility” and insert your VEXnet 2.0 key to any free USB port on your computer. Follow the instructions on the utility to update each key individually. All VEXnet 2.0 keys must be running the same version in order to function properly.
    • After updating your VEXnet 2.0 keys, you will need to update your VEX Cortex and VEX Game Controllers with version 4.20 from inside of ROBOTC. After updating your master firmware, you will also have to install the latest ROBOTC firmware as well.
    • Note that this new firmware version will support download and debugging with both VEXnet 1.0 (black) and VEXnet 2.0 (white) keys.

Here’s the list of changes and enhancements between version 4.06 and 4.08.

VEX Cortex:

  • Support for VEX Cortex Master Firmware 4.20 and VEX Game Controller Master Firmware 4.20
  • Support for wirelessly download and debugging using the new VEXnet 2.0 2.4Ghz radios.
  • Fixed an issue with launching ROBOTC in “Virtual Worlds” mode, which may incorrectly choose the wrong compiler target.
  • Fixed issue with Windows XP/Vista/8 where ROBOTC may crash when unplugging/plugging in a device

VEX IQ:

  • Improved motor responsiveness (16ms update cycles as opposed to 50ms today – this was a mitigation for the I2C issues in the current Master FW)
  • Improved sensor responsiveness (varies by sensor – this was a mitigation for the I2C issues in the current Master FW)
  • Gyro sensors can now return either integer values (getGyroDegrees/getGyroRate) or floating point values (getGyroDegreesFloat/getGyroRateFloat)
  • Fixed a bug where the Gyro sensor was not using the “rate” setting to properly return a deg/sec calculation for the getGyroRate command.
  • Exposed the ability to calibrate the gyro sensor from the user program and specify the number of “samples” to take during calibration (more samples = less drift = longer calibration time)
  • Also added a boolean “get” command to read the gyro calibration status bit to know when calibration is done.
  • New PWM adjustment function – allows users to trigger a specific VEX IQ motor to read the current battery voltage from the VEX IQ brain to adjust the PWM scale factor in the motor to ensure consistent performance. This is automatically done each time a program is executed with ROBOTC, but for longer programs end-users might want to readjust the PWM scale factor.
  • New “read immediate current” from motor – returns a value in mA
  • Modified functions for “motor strength” – renamed these to be “motor current limit” and uses values in mA instead of 0-255 byte value. These commands used to be called “getMotorStrength” and “setMotorStrength” – they’re now renamed to “getMotorCurrentLimit” and “setMotorCurrentLimit”
  • Fixed an issue with “Graphical” mode where users may start up in “Cortex” mode and the function library will appear blank
  • Fixed an issue when “Natural Language” mode was enabled that normal sample programs may not run properly (using the leftMotor/rightMotor keywords)
  • Fixed issue with Windows XP/Vista/8 where ROBOTC may crash when unplugging/plugging in a device

If you have any questions or issues, contact us at support@robotc.net. Happy Programming!!

Written by Tim Friez

March 26th, 2014 at 8:40 pm

ROBOTC Graphical Programming Preview Available!

without comments

clickanddragAfter months of work, the ROBOTC Development Team is excited to announce the availability of the first preview release of ROBOTC Graphical Language for the VEX IQ platform. This new interface will allow you to program robots from inside ROBOTC with easy-to-use graphical blocks that can be drag-and-dropped to form a program. Each block represents an individual command from the “text-based” ROBOTC and Natural Language. The new click and drag interface along with the simplified commands of Natural Language will allow any robotics user to get up and running with programming their robots as soon as possible.

The first release of ROBOTC Graphical Language is available for the VEX IQ platform for use with the standard VEX IQ Clawbot and Autopilot Robots. All ROBOTC 4.0 users will receive access to the new Graphical Language interface at no additional cost! Our plans over the next few months are to extend the Graphical Language interface to all of ROBOTC’s support platforms, including the Robot Virtual Worlds technology. You can download the preview version today at http://www.robotc.net/graphical/.

———————————————————————————————————————————————————-

The new ROBOTC Graphical programming environment adds a number of new features we’d like to highlight:

Graphical Language Command List (Drag and Drop)

GraphicalFunctionBar
With the new ROBOTC Graphical Mode, we’ve updated our “Functions Library” to match the style of the Graphical interface. This new mode will allow you to drag and drop blocks of code from the “Graphical Functions” menu into your program to get your program created even faster!

New Language Commands for Easier Programs

NewLanguageCommands
We also added some new language extensions to both ROBOTC and Natural Language; such as the simplistic “Repeat” command. Prior to the Repeat command, users would need to copy and paste large sections of code or use a looping structure (like a ‘for’ or ‘while’ loop) in order to have a set of actions repeat a number of times. With the new “Repeat” command, however, users can simply specify how many times they would like the code to run, with no complex coding required. And users who wish to make an “infinite loop” can use the “repeat forever” command to accomplish this task quickly!

Commenting Blocks of Code!

CommentingOut
Another awesome tool that we’ve implemented in ROBOTC Graphical is the “comment out” feature. You can now comment out an entire line of code just by clicking on the block’s line number. The robot ignores lines of code that are “commented out” when the program runs, which makes this feature very useful when testing or debugging code. This new tool is unique to ROBOTC’s Graphical interface.

Updated and Simplified Toolbar

Toolbar
Sometimes navigating menus as a new user can be a little overwhelming – so many options to choose from and lots of questions about what each option is used for. To help with this, we’ve redesigned ROBOTC’s toolbar to make getting up and running easier. We put the most used commands on a larger toolbar so new users have an area to easily click to download firmware, send their code to their robot, and run their programs without having to use the standard menu interface.

Convert to Text-Based Natural Language

ConvertToText ConvertToText2
Because each Graphical Natural Language block corresponds to a real ROBOTC or Natural Language function, users will be able to graduate from Graphical Programming to full text-based programming with the press of a single button. This allows users to naturally transition from Graphical Natural Language to the text based Natural Language (or ROBOTC), without having to worry about manually converting the code line-by-line!

Teacher’s Guide and Sample Programs

UsersGuide
The new graphical interface includes over 50 new sample programs to help you get up and running with working examples and demo code. In addition, we’ve also developed a 30+page guide to walk new (and existing) users through the new Graphical Programming interface and getting started with the VEX IQ platform. You can find a link to the programming guide here and also on the ROBOTC Graphical page.

———————————————————————————————————————————————————-

This initial release is only the beginning and we’re planning on improving the software with more features and flexibility over the coming months.

Future Support/Features:

  • Copy and Paste
  • Undo/Redo Support
  • Support for custom robots/configurations via an updated “Motors and Sensor Setup” interface.
  • Dynamic Loop and Command Parameters (based on Motors and Sensor Setup / Robot Configuration)
  • Tooltips, Contextual Help, and more!

Click here to download the installer!

Let us know what you think! If you have any feedback or questions, please send them along via the ROBOTC’s VEX IQ forums.

Updates to Ruins of Atlantis and Operation Reset

with one comment

We’re happy to announce that we have a fresh batch of Robot Virtual Worlds updates for you! Read on for more detail.

Ruins of Atlantis

  • We’ve added lots of really cool ocean life to the level, over 20 species of fish. See if you can spot them all! These and other visual elements can be disabled in the Options menu of the splash screen.
  • Badges for completing the Ruins of Atlantis path with each robot have been added (See below). Each of the three robots available has different dimensions, so this rewards the student for completing additional math and programming practice.
  • We’ve updated our high resolution printable map with valuable information and fun, themed elements.
  • A comprehensive teacher’s guide is now included, which covers everything from getting started, programming options available, and how to teach with the tools in the world.

Ruins of Atlantis 2

New Badges

Operation Reset

  • Operation Reset has been updated to include the latest physics engine.
  • A number of small bugs have been resolved. Thanks for the feedback!

Operation Reset

The latest versions of our Robot Virtual Worlds can always be downloaded from RobotVirtualWorlds.com or CS2N. As always, if you need help or have any feedback, please visit our forums.

Written by Jesse Flot

February 17th, 2014 at 3:55 pm

Sneak Preview: RVW Expedition Atlantis

without comments

Atlantis01Happy Friday! I thought it might be nice to end the week with a little sneak preview into our newest Robot Virtual World game, “Expedition Atlantis: A Calculated Deep Sea Adventure.” We are still working on it, so things might change, but wanted to share an inside look. The game and curriculum will be available this Fall. Check back for more info soon!

 

 

 

 

 


 

 

Written by Cara Friez

July 12th, 2013 at 5:59 pm

Announcing ROBOT 4.0!

without comments

ROBOTC-logoWe are very excited to share details on ROBOTC 4.0!! This version of ROBOTC will be getting a lot of new features as well as some enhancements to favorite tools already included. Also included in this upgrade will be support for new hardware platforms, including the new VEX IQ and LEGO EV3.

 

 

Planned Features in 4.0:

  • Overhauled Natural Language functionality to make learning how to program even easier.
  • Motors and sensor setup that will automatically detect devices (with supported platforms/devices.)
  • Enhanced drag and drop capability with our function library for new users.
  • Updated text editor with code collapsing, improved auto-complete, and more user customizability.
  • Even more sample programs to help users get started, including samples for new platforms and advanced programming concepts!
  • Support for both VEX Cortex and VEX IQ in ROBOTC for VEX Robotics 4.0
  • Support for both NXT and EV3 in ROBOTC for LEGO MINDSTORMS 4.0
  • No-Cost standalone version of ROBOTC for VEX PIC for legacy users.

Pricing and final availability for 4.0 has not been finalized; however customers can feel secure buying ROBOTC today knowing they will get a full ROBOTC 4.0 upgrade as soon as it is available.

Current ROBOTC Users Upgrade Details:

  • 3.0 Perpetual Users (who purchased in 2013): No upgrade fee! Full purchase price will be applied towards same type of license for 4.0.
  • 3.0 Annual Users (who purchased in 2013): 50% discount on equivalent 4.0 License
  • 3.0 Perpetual Users (who purchase before 2013): 50% discount on equivalent 4.0 License

If you own a license to ROBOTC 3.xx – You can continue to use 3.xx for as long as you would like (assuming you have a perpetual license) – the software will not stop working once 4.xx is released. However, if you wish to use the features and platforms available in ROBOTC 4.xx, you will have to purchase an upgrade at a significant discount.

Upgrades will be available for up to 6 months after the official release of ROBOTC 4.0. Stay tuned to the ROBOTC.net Blog – We will be releasing free beta versions throughout the year and will announce final pricing and availability details in the near future.

Written by Cara Friez

May 13th, 2013 at 1:30 pm

Robot Virtual Worlds Measurement Toolkit

without comments

Measurement-Tool-KitWe recently added a great new feature to our Robot Virtual Worlds … the Measurement Toolkit! There is no more guessing on how far a robot needs to travel to solve programming problems. It allows for intelligent path planning and navigation. You can now have students do the math, show their work, and explain how they solved the problems.

Check out our newest video that talks about what the measurement toolkit can do in RVW!

Official Release of ROBOTC 3.60!

without comments

ROBOTC 36

 

We are very excited to announce that today is the first day of Spring and …. the first day of ROBOTC 3.60! ROBOTC is the premiere robotics programming language for educational robotics and competitions. ROBOTC is a C-Based Programming Language with an Easy-to-Use Development Environment. We are really proud of this release and can’t wait to hear what you think! Remember, we could not do this without your support and feedback. We hope you’ll continue to share your comments with us, either in the forums or on our Facebook or Twitter page.
 

Some of the key enhancements are:

  • Added support for proxy server when activating ROBOTC (Proxy Support guide can be found here).
  • Add watchdog timer support to VEX Cortex to alleviate processor crashes that can occur with static (more information on this issue can be found on the VEX IME Product Page).
  • Fixed a bug in the NXT color sensor that now allows you to read individual RGB values.
  • Updated with the latest version of the 3rd party sensor drivers for NXT. (Thanks Xander!)
  • Updated Curriculum Tables included for Robot Virtual Worlds.

See below for the more detailed changelog and download ROBOTC 3.60 here!

ROBOTC Hangout
 

To celebrate the official release, we will be having our first Google Hangout! Tim Friez, John Watson, and Xander Soldaat will be there to discuss the new features and answer some of your questions. To tune in live, visit ROBOTC.net/hangouts at 2pm EST tomorrow (Thursday, March 21.)

—————————————————————————————————————-

3.59 to 3.60 BETA Changelog

VEX:

  • New Standard Models Added for PLTW.
  • Update VEX Cortex I2C interrupt handler to handle case where interrupt for last received character is not processed until STOP signal has already been sent.
  • Add parameter to I2C Device Driver (VEX Cortex) to indicate whether being called for a “timer tick” or for a “message is now complete”. Add a few more statistics to the error collection.
  • Increase VEX Cortex I2C message timeout to 6 milliseconds from 3.
  • Start sending VEX Cortex I2C polling messages immediately after last poll has finished. Improves I2C responsiveness for VEX Cortex.

LEGO:

  • Xander’s 3rd Party Driver Suite updated to version 3.3.1

Arduino:

  • New firmware conditional compiles to eliminate the get/set property opcodes for ‘long’ and ‘float’.
  • Arduino only. “Copy opcode from flash to RAM” performance improved.
  • On Arduino, sensor initialization incorrectly assumed as sensor types had the extra “sensor buffer” structure. But the extra buffer is only linked for complicated sensor types so RAM was being overwritten. Fixed.

General:

  • Updated application and desktop icon quality.
  • Fix “Multiple overloads match” error introduced with change that did proper validation of pointer expression with point procedure parameter variable.
  • Improved validation of procedure parameter matching for function overloads. Previously when parameter was a pointer, only checked to confirm that calling expression was also a pointer. Check was extended to also (correctly) match on the type of pointer as well.
  • Could not change “check array bounds” in Compiler Code
    cialis

    Optimization tab. The issue was that after changing the check mark the “code optimization type” would be recalculated and then the “optimization type” radio buttons updated. Array bounds checking is not used in determining the optimization type; but in setting the type it is modified. So the changed check mark was being accepted and then software was overwriting. Fixed.

  • Split “auto save” into two individually settable flags: (1) to auto save source files before compile and (2) auto save files when application exits.
  • Incorrect code optimization involving ‘struct’ variable offsets and perhaps other cases. For the assignment instruction “<variable2> is assigned address of <variable1>” compiler was replacing references to “<variable2> with “<variable1>. This optimization should only occur for “simple assignments” of “<variable2> = <variable1>”. Fixed.
  • Change ‘nSysTime’ and ‘nPgmTime’ intrinsic variables to “unsigned”. ‘unsigned’ intrinsic variables were being converted to ‘signed’ when used in comparison expressions generating a warning regarding mixed ‘signed’ / ‘unsigned’ comparison. Fixed.
  • Upper range check for “array bounds check” opcode used “>” instead of “>=” in comparison allowing ‘one past’ array size as valid.

3.54 to 3.59 BETA Changelog

VEX:

  • Add watchdog timer support to VEX Cortex. This will allow the VEX Cortex User Processor to “restart” automatically once the processor crashes/is halted. Useful for any potential static issue that may cause the User Processor to “crash”.
  • Change watchdog implementation from “windowed” watchdog to standard watchdog (no window, reset any time). Increase watchdog timeout to 0.75 seconds.
  • In Debugger Motors display the last motor was not always properly updated. Fixed.
  • Enable emulator for VEX PIC. Fix subsequent bug with “Motors” debugger display for VEX PIC locking up IDE when emulator is enabled; this bug should be limited to VEX PIC Emulator only.
  • VEX PIC downloading was failing when master firmware was out of date. Getting stuck in a repetitive loop that wasn’t exiting. Fixed.
  • VEX PIC was not executing user programs. Bug was that “start of flash file system VTOC” needed to be aligned on 4-byte boundary. Previous change had added a 1-byte field to the header preamble and there was not a corresponding 3-byte file added for VEX PIC. ARM platforms worked OK. This may also have broken Arduino (i.e. any 8-bit) platform).
  • Added a Conditional Compile flag for tUARTs to avoid confusion between uartOne and UART1
  • There are two separate flags for “allow any serial port for communications” — one for VEX Cortex and one for all other platforms. This was not obvious. Preferences “Environment” tab was only updating flag for non-Cortex; this has been changed to update the appropriate flag based on platform setting. The VEX Cortex flag can also be updated in the “VEX Cortex” tab.
  • User configurable UART setup was screwed up for the platforms whose “uart 0″ is fixed as non-configurable and usable only for system communications port to PC — i.e. VEX Cortex, VEX PIC. The ROBOTC IDE was storing the data in the persistent data table (at start of flash file system) offset by one entry. I.E. data for “uart 1″ on VEX Cortex was stored in “uart 2″, etc.

LEGO:

  • NXT color sensor read RGB individual values broken with pointer implementation. Change “getMemoryParmXXX” function calls to “getCommonParamaterValueXXX” function calls. Check rest of firmware for same mistake.
  • New feature for 3rd Party Sensor Driver Suite to set the two digital I/O lines on NXT sensors. Added two new sensor types (sensorCustom, sensorCustom9V) for this along with two new property intrinsic variables to set I/O line direction and values; these intrinsic variables are bit masks (2-bits) for the two lines.
  • “setPixel” intrinsic (and corresponding “clearPixel” and “invertPixel”) take “unsigned” parameters. But implementation was using “signed” parameters and not properly range checking if parameters were negative. If negative, then should do nothing. Instead they were incorrectly wring to invalid buffer address which eventually caused a firmware crash.

Arduino:

  • Fix issue for “Motors” tab for Arduino in “Motors and Sensors Setup” property sheet. Was incorrectly trying to setup “encoder information for motor”, but Arduino platform does not “associate encoder sensor with motor” — which is currently only a feature for VEX Cortex.

General:

  • Added Support for Proxy Server when activating ROBOTC – Users can set Proxy preferences under “Detailed Preferences – General – Environment”.
  • Incorrect generation of compiler error message when double pointer (i.e. “**”) is used.
  • “Print” a range of pages was not working when the starting page was not ’1′. Fixed.
  • Remove incorrect error message from error “Assignment between two different pointer types” when one side of ‘=’ is a ‘void *’.
  • Compiler was incorrectly generating error message for “Expected a pointer expression in a pointer expression with ‘++’ or ‘-+’ operand. Compiler was incorrectly checking to verify the right operand was an integer value.
  • Compiler was incorrectly generating error message for “Invalid pointer expression” in a pointer expression with ‘+’ or ‘-’ operand. One operand of the expression must be a pointer and the other operand must be an integer (without implied conversion of a pointer to an integer). Compiler was incorrectly checking for the integer — the expression incorrectly had a “!” in it!
  • Change code generation of ‘var arg’ for pointers to be consistent with standard C — i.e. the value of the pointer is placed in the argument. This may result in an additional instruction generated when argument is a ‘string’; previously RobotC got too cute trying to save this extra instruction which only worked for “%s” format codes but was broken for “%d” on a pointer.
  • In ‘sprintf” implementation for “%s” and “%p” format codes– change from  “get Address of parameter” to”get value of parameter” to match corresponding change in compiler code. Also minor cleanup of “%s” and “%p” format codes.
  • Assignment expressions of “<char * variable> = <char constant> were generating compiler error because the “<char constant>” was evaluated as a “string” type. Added code in “get expression type” to check for this and not generate error as the compiler auto converts “string” to “char *” during code generation.
  • Fixes an issue with the Live Start Page and “check for updates” that may have caused crashes.
  • Improved validation of pointer expressions. Fix bug in calculating expression type of pointer expressions like “<ptr sub-expression> + <numeric constant>”; the result was (always?) incorrectly set as “long *”? Also added check that “=” of pointer is from a pointer of the same type – otherwise generate error message.
  • Fixed consistency in implementation of “random” intrinsic property.
  • Eliminate compiler error message in constant expression evaluation of sub-expressions using “*” operator. If either of the two operands is ‘zero’ then result is zero regardless of whether the other operand is a compile time constant.
  • Do not generate additional errors — “too many parameters” specified — when procedure is “compiler generated undefined symbol”.
  • When switch between “real robots” and “emulator”, the function that calculates “size of RAM pointer variable” was not being called. It adjusts between 2-byte (VEX PIC, Arduino) and 4-byte (Emulator, VEX Cortex, NXT) pointer sizes. No issue with VEX Cortex and NXT as they only use 4-byte pointers. But a problem with VEX PIC and Arduino where real robots use 2-byte RAM pointers! Added the appropriate call to function setup.
  • Small code optimization for “postfix –”/postfix ++” operators to avoid temporary. In some cases they can be simplified to prefix operands.
  • Incorrect initialization of static variables in “inner scope” for local procedure. They were initialized every time inner scope block was accessed rather than once on program startup.
  • Debugger Panes for “Locals” and “Globals” (especially Globals) was not properly handling updates to ‘long’ and ‘float’ variables. Globals was completely broke — only lower two bytes of 4-byte variables was being updated which broke ‘long’ and ‘float’ variables. In both, ‘char’ variables were updating a short value — i.e. overwriting following characters.
  • Fix problem with incorrect user code using a “short” variable and “sprintf” format code of “%f”. This can crash ROBOTC VM firmware if the short variable is not aligned on a 32-bit boundary.
  • Add additional entries for StringFind for Character Constants and added test program.
  • Redefine datalog opcodes and intrinsics. Legacy datalog incompatible with 3.5x VM operands which split memory variables and intrinsic properties into separate items.
  • Firmware for all platforms now call “datalogHandlerInit()”. Conditional compile will define as NULL macro if a platform does not support Datalog. Datalog support is now conditionally compiled via “bHasDatalog” define rather than hard-coded as NXT only.
  • Fix incorrect compiler type checking error when string constant is assigned to a char pointer.
  • Fix bug in check for “is this a preprocessor string comparison expression”.
  • Eliminate preprocessor string comparisons in Natural Language and replace with “defined(_Target_XXX_) where “_Target_XXX_” are three new system defined preprocessor variables — “_target_Robot_”, “_Target_Emulator_” and “Target_VirtWorld_”. Sample programs modified appropriately. Legacy user programs using legacy definitions will still work but will generate a compiler warning about non-standard extension.
  • Add registry flag to enable compiler extension to allow preprocessor expressions support for string comparisons. Generate compiler error message if encountered without the flag being set.
  • “cast” code generation fix. Previously when cast changed sign of result the ‘cast’ was applied before expression was converted to ‘int’ size used during a calculation. So casting a “ubyte” to “int” incorrectly converted it to a “signed char”. What should happen is “ubyte” expression gets evaluated into an “int” as part of expression evaluation (all expressions are evaluated at ‘int’ (or higher) level in “C”) and then the cast to “int” has no additional effect.
  • Function to extract numeric “COMxxx”. Expanded syntax to support successful parsing of “(COM99)” previously would not accept extraneous characters.
  • Add improved Dialog for selecting Communications Port. It uses a list box to display information about the port. Add check box to select any communications port.
  • Compiler crash when parsing invalid syntax of ‘?’ expression. Compiler was not handling the case when “NULL” pointer returned from parsing sub-expression. The “NULL” was incorrect.

Written by Cara Friez

March 20th, 2013 at 2:58 pm

New Versions of RVW Curriculum and Competition Tables

with one comment

The Robot Virtual World team has a fresh round of updates available for you. We’ve listened to your feedback and have made some changes to our Curriculum Companion, Sack Attack, and Ring It Up virtual worlds. Read on for more details!

What’s new in the Curriculum Companion 2.2.4:

  • Adjusted the NXT – Obstacle Course table to more closely meet the level specifications
  • Adjusted the VEX – Robo Slalom 2 table to give more room between the lines and obstacles
  • Adjusted the Camera 2 View of the VEX – Minefield Retrieval Challenge

What’s new in VEX Sack Attack 1.5.1:

  • Resolved a bug where motor values were being overwritten

What’s new in Ring It Up 1.5.1:

  • Resolved a bug where motor values were being overwritten
  • Adjusted robot models to drive straighter
  • Adjusted sensor and encoder behavior
  • Improved the gripper-ring interaction behavior

Thanks again for the feedback, and keep it coming. You can post it to the Robot Virtual Worlds section of the ROBOTC Forums.

Written by Jesse Flot

November 19th, 2012 at 4:54 pm

FTC Ring It Up and VEX Sack Attack v1.50 Now Available!

with 2 comments

Following up from an earlier post, new versions of the FTC Ring It Up and VEX Sack Attack Virtual Worlds are now available!

In version 1.50 of Ring It Up, all arm, wrist, and gripper motors now include encoders, allowing you to get feedback and implement precise control over the robots. We’ve also swapped the Compass Sensor for the Gyroscope, which was highly requested by FTC teams. New Sample code  for the encoders and gyroscope is installed with the world.

 

In version 1.50 of Sack Attack, we’ve added encoders to the arm motors on all of the robots, and a potentiometer to the scooper motor on Scooperbot, giving you very precise control. All robot models have also had the Compass sensor replaced with a Gyroscope, better aligning them with the real world VEX system. As with the Ring It Up world, Sample code for all of the new functionality is included.

We genuinely appreciate all of the feedback and comments we’ve received about these worlds, and we hope that these changes show that we’re listening. Keep the feedback coming!

Adding support for all of the new inputs required a significant update of our back end, so these versions require ROBOTC 3.54 or later to be installed. Happy programming!

Written by Jesse Flot

November 5th, 2012 at 1:33 pm

Posted in NXT,Releases,VEX

Tagged with , , , ,

ROBOTC 3.54 Update Now Available!

with one comment

The ROBOTC development team is happy to announce the release of ROBOTC 3.54. This new version adds a number of new features and numerous bug fixes from user reports. Existing ROBOTC 3.xx users can download a free update from inside of the ROBOTC software (Help – Check for Updates) or from the ROBOTC.net website.

In addition to ROBOTC 3.54, the ROBOTC Development team is excited to announce support for PID with the VEX Cortex system (using motors with integrated motor encoders). The new VEX PID functionality will be available in a public BETA to be released in the very near future.

The latest update to ROBOTC also includes a number of new features for Robot Virtual Worlds. The new update includes new support many more motors, encoders and sensors. Look for an update for your favorite virtual worlds in the near future to take advantage of this great new functionality.

A summary of the major changes are below:

LEGO/TETRIX:

  • Support for MATRIX Robotics “Move to Encoder” in NXT firmware using the nMotorEncoderTarget functionality.
  • Fix TETRIX motor control. “Move to encoder position” functionality was not working correctly.
  • New functionality for I2C test program to optionally create message log traces for I2C ‘write’ and ‘read’.
  • TETRIX user defined servo names were not being properly setup by compiler. Fixed.
  • nxtDisplayRicFile intrinsic was broken. Auto downloading of files from PC was disabled. Both are fixed.
  • Xander’s 3rd Party Sensor Drivers (from BotBench.com) are now updated and compatible with ROBOTC 3.54. The new driver are included in the NXT Sample Program’s directory.

VEX Cortex/PIC:

  • Fix bug related to ‘char *’ and ‘string’. It was introduced with fix for “playSoundFile” not working. “playSoundFile” is now working for the Cortex.

General ROBOTC:

  • Support for “Classic Mode” – This mode will disable the “variable stack” and treat all variable as “Global Variables” like ROBOTC used to before version 3.50. This setting is under “view – preferences”.
  • Enhance directories for “Sound” files. There are now three possible choices — “common files” directory, “platform specific” directory and “user specified” directory. Implemented separate “Preferences” tab for “sounds”.
  • Add new “Motors and Sensors Property Page” to configure size of “datalog” and “debug stream” buffers. Applicable to super user level only.
  • Clear highlighted execution line when “Debugger” closes. Previously the line of current execution was left highlighted.
  • Add support for “mouse wheel” with “Debug Stream Window”.
  • Add command to “compile all source files in specified directory. Add separate pane to retain the new “multi-file compilation” errors. The normal error window is erased on next compile and you’ll likely want the multi-file results to hang around.
  • Support for multiple user defined directories for compiler include files. Split “Detailed Preferences” into multiple property sheets when not menu basic and multiple tabs to display.
  • Instead of hiding command for invalid debugger pane during Emulator/Virtual Worlds, the command is shown – When opened a message box will display indicating that window is not supported under emulator/virtual worlds.

ROBOTC Compiler and Other Fixes:

  • Incorrect calculation of expression type of form <condition> ? true : false. Expression type was incorrectly calculated as a “integer type” rather than a “boolean type”. Fixed.
  • Fix type in calculating binary expression numeric type.
  • Fix incorrect calculation of expression types involving float constants. They were being set to “integer” type.
  • Changed a few intrinsic procedure parameters from ‘int’ to ‘short’.
  • Incorrect calculation of compile time constant code was resulting in unnecessary code generation for a complex, but constant value, expression.
  • “Terminate expression parsing priority” comparison was effectively  “>=” instead of “>”.  Priority was being screwed up so that expressions “A + B – C” was generating code for “A – (B + C)”
  • A few cases of “compile time constant” expressions values were not detected by compiler resulting in run-time code calculation for constant expressions. Specifically “0 / XX” is always zero regardless of ‘XX’ value. Also, constant expression of form AA = <numeric one> – <numeric two>” was generating code for run-time calculation even though could be calculated at compile time. Fixed.
  • VM opcode uses 16-bit unsigned constant. But compiler was checking if 16-bit SIGNED value was in range.
  • Incorrect compiler error message about array index out of bounds is possible when index is expression like “<constantVar> + numeric constant>”. The code for checking array bound range was only looking at “<constantVar>” and not including the <numeric constant>”. This is fixed.
  • Fixed an error that did not mark precompiled headers as invalid if the precompiled source file had any errors from the previous compile attempt.
  • Created separate Sample Program Root folders when in Virtual Worlds mode.
  • Benign. Better support for type checking “void” and “void *” expressions to eliminate incorrect compiler warnings.
  • Fix code generation for ‘string’ types. There were issues with “const string” variables having improper memory allocated. Improve code generation for assignment of “&” (address of) operator to avoid an unnecessary temporary.
  • Eliminate legacy code that re-ordered syntax tress to optimize code generation for numeric. This was not “standard C” compliant because it re-ordered the order of how expressions were evaluated. Code generation is nearly as optimal except something like “X = 5 + y +6″ will separately generate instructions to add ’5′ and ’6′ rather than a single add of ’11′
  • Better implementation of “type checking on string expressions”. Old implementation was occasionally generating incorrect compiler errors.
  • Add support (in emulator only) for invalid pointer calculation in “get address of parameter” opcodes. It performs a range check to ensure calculated values are in range. This is not a complete check for invalid pointers but will catch many occurrences of unassigned pointers.
  • Code generation for “large constants” (i.e. doesn’t fit in two bytes) was broken. Fixed.
  • Incorrect calculation of “assign “&’ value to variable”. Bug recently introduced with string fixes.
  • Improve code generation for ‘char string constants’.
  • Add error message when no parameter is specified for nMotorEncoder/Motor/SensorValue/etc.
  • Fix a few small issues in Licensing System for oft-used cases.
  • Add compiler error message when no “main task” is defined.
  • Add compiler error message that “&” is snot supported as part of a ‘cast’ qualifier. This is a C++ feature and not found in ANSI C.
  • Fix bug in code generation for “goto XXX;” statement. Compiler optimization may not emit the unconditional branch and code generation was not handling the case of  a NULL pointer that resulted.
  • Fix code generation problem with large constants (i.e. >16 bits) assigned to long variable. Compiler was incorrectly trying to generate code for optimized short forms (i.e. 16-bits or smaller parm index).
  • “Events” no long work. Delete the sample program that illustrates them.
  • Incorrect calculation of operator parsing priority for “&” (address of unary op) which should be ’3′. Instead it was using the priority for ‘&’ (bit and) which is priority ’10′.
  • Fix incorrect code generation when assigning ‘float’ expressions to ‘int’ (char, short or long) variables.
  • Fix compiler code generation for expressions using pointer subtraction — “<pointer> – <pointer”. also fix “<pointer> – <number>”
  • Fixing an issue when a license is in the “clock rolled back” state and needs to be reset using a 30-day reset key – previously was not updating the “clock rolled back” state.
  • Compiler does not handle ‘const string kConfigName = “FTCConfig.txt”;’ properly. Changed to ‘string kConfigName = “FTCConfig.txt”;’.
  • Fix recent bug where “*” in declaration of type “typedef OBJ *POBJ” was being discarded. Extend typedef parsing to support declaration like “typedef unsigned char ubyte, *PUbyte”; i.e. change single declaration to a comma separated list.
  • Debugger window for NXT Remote Screen in emulator was not properly recognizing the remote buttons. The message sent to emulator should have been a mask of buttons and instead was a index of a single button. Fixed.
  • NULL char in middle of char string constant — e.g. “abc\0def” — resulted in incorrect storage by compiler into constant pool. Only the chars up to the NULL were being stored. Fixed.
  • Char arrays whose array dimensions were initialized with empty bounds were incorrectly assigned one byte too large. The trailing NULL on the end of the char string constant was being included in the array dimension.
  • Token scanner was not properly handling ‘\ddd’ special chars where ‘d’ is octal digit. This is now fixed and the standardized format for hex digits of ‘\xhh’ is also accepted.
  • Complete implementation of new registry toggle to optionally automatically close start page on first user compiler. Also added as a command to the menu “View -> Preferences -> Close Start Page on First Compile”.
  • Compiler was not parsing postfix “++” and “–” properly when they followed an expression. It worked fine on expressions with simple variables — “structVar.NN++” or “pStructVar->NN++” but didn’t work for more complicated expressions like “((TStruct *) &strucVar)->NN++”. It now handles the complicated expressions.
  • Fix incorrect calculation of “useless expressions” for binary opcodes. Compiler detects ‘useless’ expressions and does not generate code for these. It was incorrectly flagging binary “+”, “-”, … operations as useless which is incorrect if one of the parameters has side effects like being a procedure call or an expression like “++” or an expression containing a “=” operator.
  • Compiler crash when “++” or “==” were to expressions that didn’t immediately resolve to a symbol. e.g. “++((&g_obj)->n2);”.
  • Fix code generation for expression like “(&OBJ)->n1″. Was throwing compiler error and generating incorrect code.
  • Clear Debugger “Local Variables” pane when user program is finished or executing (vs suspended). When executing, don’t know which local variables (on stack) are valid.
  • Expanded declaration support for statements like “int A, * B, *C, D;” where A and D are “int” and B and C are “int *”
  • Signed / Unsigned type fixes for pointer variables. Allow “const string” procedure parameters to be matched by char constants (e.g. “ABC”).
  • Fix issue with compiler indicating reference variables are only “read” but not “written”.
  • Compiler was incorrectly assigning the ‘signed’ type of pointer variables to “unsigned” (i.e. the signed value of a pointer) rather than the desired type. Formatting routine for this was also broken.
  • Ignore “find best procedure fit” parameter array checking when “void *”. “Void *” will match any pointer regardless of arrays.
  • Improved calculation of expression result types for binary opcodes.
  • Intermediate expressions were always converted to ‘signed’. Now if both operands (e.g. A + B” are unsigned then the expression result is also unsigned.
  • Calculating best fit procedure was not checking array bounds of parameters for matching indices when the parameter was a pointer variable and an array variable. Fixed.
  • “cast” operator now preserves signed type of typedefs that it references. Previously this information was lost.
  • ‘signed’ and ‘unsigned’ now work properly when used in a “cast”.
  • ‘char strings’ when used as arguments to ‘sprintf’ were broken. Fixed.
  • Eliminate some overly aggressive warning messages about mixed expressions of numeric and ‘enums’. Standard C does not perform this level of checking and allows much more liberal mixed mode without warnings/errors.
  • Better support for arrays. Allow variable to be declared with arrays that is based on a typedef that also specifies arrays. Previously arrays could only be declared in one “item”. Array bounds were not checked for integrity (i.e. the bounds match) when validating procedure parameters and calculating best fit procedure when multiple procedure overloads.
  • Improved generation of “&” (address of) code.
  • Improved type checking to allow equivalent but differently declared operand types to match. Previously had to be exact match.
  • Generate compiler error for ‘&’ operator applied to a “property” (motor, servo, encoder, sensor) variable.
  • Generate compiler error for ‘&’ operator applied to a numeric constant.
  • Fix code generation for expressions like “char *ptr2 = buffer;” where ‘buffer’ is a implied pointer (e.g. a array of char). Previously code generation was assigning the contents of the first element of the array to “ptr2″ rather than the address of “buffer”.
  • If the previous line triggered an “indent” — like a “if (xxx)” or “else” statement then next line was auto indented and when “{” is entered want to “undent” the auto indent. Add check for this case.
  • Minor bug in calculation constant expression with unary ‘-’ with a constant numeric parm. Fixed.
  • Code optimization for conditional branches with trinary opcodes where the trinary condition is a compile time constant.

Written by Tim Friez

November 3rd, 2012 at 2:15 pm