ROBOTC.net Blog  

ROBOTC News

Archive for the ‘Update’ tag

Announcing ROBOTC 4.10 now available!

with 3 comments

Summer 4.10The ROBOTC Development Team is excited to announce the availability of ROBOTC 4.10 – an update for the both the VEX Robotics (Cortex and IQ) and LEGO Mindstorms (NXT and EV3) robotics systems. This new version includes new features and functionality for all ROBOTC 4.X compatible platforms.

  • Full support for the VEX IQ platform in ‘Robot Virtual Worlds’ – Updated “Curriculum Companion” to support VEX IQ
  • Support for VEX IQ 2.4Ghz International Radios (Requires VEX IQ Firmware 1.10 or newer)
  • Initial Support for I2C devices with EV3 platform
  • Updated Graphical Natural Language with new colors and commands!
  • Support for nMotorEncoderTarget in Virtual Worlds (NXT & Cortex Platforms)
  • Support for motor synchronization in Robot Virtual Worlds (NXT Platform)
  • Initial update of ROBOTC documentation (VEX Cortex/IQ Platforms)
  • Support for Project Lead the Way (PLTW) 2014-2015 School Year Users

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

LEGO NXT Users

  • Simply update to the latest ROBOTC firmware from inside of ROBOTC.

LEGO EV3 Users

  • Update your LEGO EV3′s Firmware/Kernel by connecting your EV3 and select “Download EV3 Linux Kernel” from inside of ROBOTC – This process will take about 5 minutes and will allow your EV3 to communicate with both ROBOTC and the EV3 Icon-Based programming language. After updating your EV3′S Linux Kernel, you’ll be able to install the ROBOTC firmware from inside of ROBOTC.

VEX IQ Users

  • Run the “VEX IQ Firmware Update Utility” and update your VEX IQ Brain to firmware version 1.10. You will also need to update your VEX IQ Wireless Controller by attaching it to your VEX IQ Brain using the tether cable. 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.22 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 the “VEXnet Key 2.0 Firmware Upgrade Utility” utility here.
  • Link: http://www.vexrobotics.com/wiki/index.php/Software_Downloads
  • 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.22 from inside of ROBOTC. After updating your master firmware, you will also have to install the latest ROBOTC firmware as well.

Here’s the list of changes and enhancements between version 4.08/4.09 and 4.10.

New Features

  • Full support for the VEX IQ platform in ‘Robot Virtual Worlds’ – Updated “Curriculum Companion” to support VEX IQ
  • Support for VEX IQ 2.4Ghz International Radios (Requires VEX IQ Firmware 1.10 or newer)
  • Initial Support for I2C devices with EV3 platform
  • Updated Graphical Natural Language with new colors and commands!
  • Support for nMotorEncoderTarget in Virtual Worlds (NXT & Cortex Platforms)
  • Support for motor synchronization in Robot Virtual Worlds (NXT Platform)
  • Initial update of ROBOTC documentation (VEX Cortex/IQ Platforms)
  • Support for Project Lead the Way (PLTW) 2014-2015 School Year Users

Bug Fixes

  • Fixed issue when deleting graphical blocks and ROBOTC would crash.
  • Improved error messages/status messages for Tele-Op based downloads with VEX IQ
  • Improved Licensing system features to provide more debugging feedback for -9105 errors.
  • Fixed to revert issue causing bad message replies on the VEX Cortex system which prevent downloading user programs. (4.09 only)
  • Updated CHM files and fixed issues in ROBOTC opening the wrong CHM file.
  • Update colors properly with the new document architecture with graphical.
  • EV3 – Casper update to prevent crashing when using VMWare Virtual Machines.
  • VEX IQ Graphical – Add USB ‘Directional Pad/POV Hat’ values for use with armControl with Virtual Worlds for IQ
  • VEX IQ Graphical – Added the ability for Graphical XML Documents to contain “RBC Macro” parameters.
  • Licensing system update to fix “heartbleed” like issues that may be present during activation.
  • EV3/IQ – Eliminate duplicate identical definitions in robotcintrinsics.c for motor commands.
  • Add new EV3 commands for sending I2C messages
  • Fix a bug in compiler generation of ‘string’ concatenation (i.e. “+”) operator.
  • Bug in code generation. Incorrect generation of opcode bytes for “opcdAssignGlobalSShort”; old format using 1-byte global index instead of new format with 2-bytes.
  • Update timeouts for VEX Cortex with new Master Firmware 4.22 for use with VEXnet 2.0 Radios.
  • Renamed DrawCircle to drawCircle
  • Fix Compiler bug with “%” and “>>” opcodes. Most of the “>>=”, “<<=”, “%=”, “&”=, “|=”, and “~=” opcodes don’t care whether the left-hand operand is ‘signed’ or ‘unsigned’. That’s how they were treated in current compiler / VM. However, “>>” and “%” opcodes do care if “signed’ vs ‘unsigned’ where the operand size is either ‘char’ or ‘short’. This change fixes that situation. This problem has been undetected since the introduction of ‘unsigned char’ and ‘unsigned short’ types were introduced.
  • 4WD Support for Natural Language with VEX IQ.
  • VEX IQ Graphical – Changes to “moveMotor” command to allow it to move in reverse if user specifies a negative quantity or speed, not just speed
  • VEX IQ Grahpical – Adjust the Graphical arcadeContorl and tankControl commands to only show channels; adjust armControl to only show buttons; add default values to most commands
  • Virtual Worlds – regulated motor movements for RVW;
  • VEX IQ – Fixed VEX IQ bug where I2C traffic would be considered “timed out” on VM startup.

As always, if you have questions or feedback, feel free to contact at support@robotc.net or visit our forums!

Written by Cara Friez

May 28th, 2014 at 8:12 pm

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!!

 
 

Robomatter Blog Ad VEX IQ

 

Written by Tim Friez

March 26th, 2014 at 8:40 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

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

ROBOTC 3.50 Now Available!

with 4 comments

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.

Written by Jesse Flot

September 18th, 2012 at 5:46 pm

New Version of the RVW Curriculum Companion Challenge Tables!

without comments

The ROBOTC Robot Virtual World team is extremely proud to announce a brand new version of the RVW Curriculum Companion Tables for both LEGO and VEX. This new version (2.2.1) contains an incredible number of enhancements and new features. It is a free update for all existing Robot Virtual World users. Read on to find out more!

New Login Functionality
If you have an account on the Computer Science Student Network (CS2N.org), you can now log in and earn achievements. This also allows you to save your progress – marking the challenges that you’ve completed so far. If you don’t have a CS2N account, what are you waiting for?


If your computer isn’t online, you can also create a local account to log in and track your progress locally. If you’re not interested in tracking your progress, you can always take advantage of the “Log In as Guest” feature, too.


Achievement Badges and Updated User Interface
As the new login functionality implies, we’ve also added achievement badges to the challenges! You can earn Motivation badges as you work through a given challenge, Progress badges as you complete challenges, and Mastery badges when you complete specified sets from the Movement, Sensing, Remote Control, and Variables sections of the Curriculum Companion Challenges. For additional background information on badges, visit this page on CS2N.

We’ve upgraded the user interface to indicate which challenges have achievement badges. Challenges with badges have a star next to their name on the list on the left. Clicking on the challenge provides additional detail.


Whether you’re logged in with a CS2N or a local account, the new Badges section displays all of the challenges that you’ve earned so far.


From the Badges section, you can also generate a PDF of all of your Progress and Mastery badges.


And if you’re using your CS2N account, you can check your progress on your Achievements page.


New In-Game Animations and Notifications
We’ve also added brand new animations and achievements to the challenges. You’ll be notified when you complete the challenge, or if your robot does something that that causes it to fail. Motivation and Progress badges will appear as you earn them on the challenges.


Challenges that require a number of laps to be performed or for certain lines to be crossed now include visual cues such as counters and 3D makers.


Robot Physics and Size Improvements
All VEX, LEGO and TETRIX robots have had their size and physics adjusted to more closely match their real-world counterparts.


Many More Small Fixes and Enhancements
There’s too many in this category to list, so try the latest version out for yourself! Download it here.

For more information about the Robot Virtual World software, or help getting it up and running, visit this page.

Written by Jesse Flot

July 23rd, 2012 at 3:49 pm