Archive for November, 2010

Apollo, The Littlest LineLeader

with one comment

[Click to enlarge]This is Apollo, the smallest NXT based line follower I’ve ever made.  It’s loosely based on A-Maze-Ing, which I designed and built quite a while ago.

Apollo is equipped some pretty cool stuff:

The program in this robot is based on the same one I wrote for the Mean Lean Line Leading Machine. I made some improvements, of which includes the ability to enter the PID and speed parameters with the Numpad, rather than going through them with the NXT’s arrow keys.  You can also navigate the menu using the “2” and “8” keys for up and down and use “#” to make a selection.

I made a video of Apollo to try and show how the menu and Numpad sensor work but it’s a bit hard to really do it properly with Windows Live Movie Maker.  That’s my excuse for the quality of this video and I’m sticking to it!

YouTube Direct Link 

The source code for this robot will be part of the next release of the ROBOTC Driver Suite.

Original post here: [LINK].

Written by Xander Soldaat

November 29th, 2010 at 9:58 am

Posted in Cool projects

Tutorial Videos: Using the Shaft Encoders with the VEX Cortex

without comments

Shaft Encoders, sometimes called a “rotation sensors”, measure the amount of rotation on the shaft, or axle, which passes through the its center. As the axle turns, the encoder “counts”. The shaft encoder measures 360 counts per revolution, and counts up for forward movements and down for reverse. By monitoring the axles connected to your robot’s wheels, the encoders allow you to control the overall distance the robot travels.

We’ve completed a set of tutorial videos in the VEX Cortex Video Trainer that will teach you in-depth how the encoders work, how to use feedback from the sensors to control the distance the robot travels, and how to use the ROBOTC Sensor Debug window to view those values in real-time.

To navigate to the videos, open the VEX Cortex Video Trainer, head to the Movement section, and choose Shaft Encoders. The 5 tutorial videos, along with helper documents, programming challenges, and additional resources are all available for free from that page!

Written by Jesse Flot

November 24th, 2010 at 4:09 pm

Posted in Cortex,General News,VEX

ROBOTC for Beginners

with 8 comments

We are working on making ROBOTC simpler and more beginner friendly! Here is our documentation for some new, simplified functions.  Each function can be used both with and without parameters!  (Everything is designed to work for the default REMBOT, but is customizable through parameters for more advanced users.)

Take a look and let us know what you think!

NOTE: we have not yet released this version of ROBOTC to the public.

Written by bfeher

November 24th, 2010 at 4:04 pm

Posted in NXT

Tagged with , , , , ,

Avoider/Climber robot

without comments

Thanks DiMastero for posting this!

For those of us who have encountered obstacles with our robots that always seem to derail our current path, you will appreciate this robot.

DiMastero has figured out a way to solve our woes dealing with unleveled ground.

Presenting… the Avoider/Climber robot…

Side View


Side view 2




It’s programmed to first drive forwards, until one of the bumpers is pressed. It then stops the wheel at that sensor’s side, and spins the other one until it’s pressed too, making sure it’s at a 90° angle from whatever is in front of it. The next thing it does is check the US sensor. If the distance to the object is less than 9 cm, it knows the obstacle is too high to climb, goes backwards and turns approximately 90°. When the sonar sensor’s value is below 9 cm, though, the middle motor, with the claw, turns a full turn, to hop the bot onto the platform. The avoider/ climber can do all of that in any order, enabling it to survive in a labyrinth with different floor levels, for example. The programming was done on RobotC.

Below is a video of it doing it’s thing:

YouTube Direct Link 

I’m open to any questions or suggestions for improvement.


Written by Vu Nguyen

November 24th, 2010 at 10:16 am

Posted in Cool projects


with one comment

CIMG7879Part Lego, part Arduino, part BoeBot, this is Frankenfollower. This robot was programmed in ROBOTC for Arduino, a port that is still in alpha stage of development but can be used quite nicely for programming the Arduino Duemilenova.  Other Arduino variants will be supported very soon.

The Arduino port of ROBOTC has some really cool features:

  • Easy to use sensor and motor configuration UI
  • Breakpoints and a debugger
  • Ability to watch your variables live
  • Multiple tasks (4 at the time of writing)

I’ve taken some pictures of the UI, so you can have a look.  Please note that the appearance of these UIs will probably change before the final version, so keep that in mind.

[Click to enlarge] [Click to enlarge] [Click to enlarge]
Main UI with some code (Frankenfollower’s code, actually) Debugger UI with variables window docked on the right. First configuration tab. This one allowed you to configure the platform and possible shields (up to 3 at the moment)
[Click to enlarge] [Click to enlarge] [Click to enlarge]
Motor and servos are configured here.  Encoders are currently not supported. Analogue pins are setup in this tab. Digital pins can be configured as PWM, input and output.

So as you can see, it’s all quite functional at the moment.  I’ve made a small video with some additional pictures of Frankenfollower and some footage of it in action.

I’m sure I’ll expand on Frankenfollower in the next few weeks, so keep an eye out on my blog!

Original article featured here: [LINK].

Written by Xander Soldaat

November 21st, 2010 at 3:34 pm

Posted in Cool projects

Tagged with , ,

Binary Calculator

without comments

Big thanks to DRV47 for posting this!

Have you ever sat and wondered, “Man.. I would love to be able to have a robot that could read a string of lego bricks that I put in a row and tell me the binary representation for it… and maybe even add or subtrack the numbers. Hmm…”


DRV47  has built this robot for you. The robot uses an NXT and is built using a single NXT 2.0 kit that you can get off the shelf from local stores nowadays.

They programmed in, of course, ROBOTC.

Take a look at the photos below:

The Binary Calculator

LEGO Bricks in a row used to represent binary numbers

Top view of the Binary Calculator

How it works

First of all, to understand how the robot works, you have to know what binary numbers are.

A binary number is written using only two different digits (0, 1) whereas the decimal system uses ten (0 to 9).

To see how it is written, let’s take an example: 10010110 (which in fact is 150 in decimal).

Every digit represents a power of two. The first digit from the right is multiplied by 2^0, the second is multiplied by 2^1 and so on.

Thus, this number is equals to: 1*2^7 + 0*2^6 + 0*2^5 + 1*2^4 + 0*2^3 + 1*2^2 + 1*2^1 + 0*2^0 = 128 + 16 + 4 + 2 = 150 (this also equals 1 * 10^2 + 5 * 10^1 + 0 * 10^0)

Here, we will use an 8 bit number which uses up to 8 digits. The biggest number will be 255 (11111111 in binary) and the smallest will be 0 (00000000 in binary).

To represent the number and operations (which will be ADD, SUBTRACT, MULTIPLY and DIVIDE), we will use a color code which is as follows:

  • RED = 1
  • BLUE = 0
  • RED = ADD

The LEGO Color sensor will read the colors and convert them to numbers or operations after the user inputs numbers and operator as follows:

Explanation of bit count and operations

Explanation of bit count and Operations

By default, the Color Sensor will read 0 and if there is no operation it will show “None” and end the program. The NXT screen will show information such as the read number (first in decimal, then in binary) and the total (first in decimal, then in binary). It will also show what it is reading. Please note that the Total can exceed 255 and can be less that 0.

This is a video showing the robot in action:

YouTube Direct Link 

You can download the LDD file here (.7z) or here (.zip) and the RobotC source-code here. I have broken the robot into several groups within the LDD file, it should be fairly trivial to reassemble it using the pictures.

All comments are welcome and if you wish to contact DRV47, you can send him an e-mail at


Written by Vu Nguyen

November 17th, 2010 at 9:58 am

Posted in Cool projects,NXT

ROBOTC for Arduino – Looking for Alpha Testers!

with 9 comments

Hey ROBOTC Community!

We’re currently looking for Alpha Testers to help us work out the kinks in our new ROBOTC for Arduino software.

In order to sign up, we ask if you can spend 5 minutes giving us some information about what kind of Arduinos you have and what your background is. Sometime in the next week, we’ll send out an e-mail to everyone who we’re inviting into our Alpha trials to let them know they made it.

Every person who participates in the Alpha will receive a free copy of ROBOTC for Arduino once it is released.

To sign up, fill out our survey today!

Written by Tim Friez

November 15th, 2010 at 5:08 pm

Posted in Arduino,General News

Tagged with ,

Controlling Pneumatic Actuators in ROBOTC

with 4 comments

Pneumatic Actuators translate the force of compressed air into fast and powerful motion. In the VEX Robotics System, all pneumatic actuators create linear (in-and-out) motion, although rotary actuators do exist. The compressed air that powers the actuators is stored in a reservoir tank; differences in air pressure between the actuators and tank cause the actuators to move in and out.

The flow of air between the tank and the actuators (directly related to the differences in air pressure)  is controlled by a small switch, called an electromagnetic solenoid, which connects to the VEX PIC or Cortex using a standard 3-pin wire. It’s a common misconception that, since the solenoid enables motion, its 3-pin wire should plug into one of the MOTOR ports on the microcontroller. Actually, a solenoid is what’s considered a “Digital Output”, and should be plugged into one of the DIGITAL ports on the Cortex, or ANALOG/DIGITAL ports on the PIC.

To configure the solenoid in ROBOTC, go to the Motors and Sensors Setup menu, and select “Digital Out” as the sensor type.














Then, in ROBOTC, when you want to activate the pneumatic actuator controlled by the solenoid, you set its value equal to “1”. To deactivate it, set its value equal to “0”. In the sample code below, the remote control buttons are used to activate and deactivate the pneumatic actuator.

#pragma config(Sensor, dgtl7,  solenoid,            sensorDigitalOut)
//*!!Code automatically generated by ‘ROBOTC’ configuration wizard               !!*//

task main()
while(true)                   // Loop Forever
if(vexRT[Btn6U] == 1)           // If button 6U (upper right shoulder button) is pressed:
SensorValue[solenoid] = 1;  // …activate the solenoid.
else // If button 6U (upper right shoulder button) is  NOT pressed:
SensorValue[solenoid] = 0;  // ..deactivate the solenoid.

For more information on using pneumatic actuators, check out our Pneumatics lesson from the VEX 2.0 Curriculum.

Written by Jesse Flot

November 11th, 2010 at 4:12 pm

Released: 3rd Party ROBOTC Driver Suite V1.7

without comments

A new release of the Driver Suite has been uploaded to Source Forge.

  • Added Dexter Industries GPS driver + test program
  • Added Mindsensors Numeric Pad + test program
  • Added new "driver" with statistical functions
  • Changed HTGYROstartCal in HTGYRO-driver.h to do more sampling for calibration data
  • HTRCXreadResp in HTRCX-driver.h now clears all of the response buffer
  • Made all calls in TMR-driver.h more robust when used in multiple threads.  No guarantee that this works.

Thank you’s:

  • Mindsensors for giving me one of their Numeric Keypad sensors
  • HiTechnic for giving me an Angle sensor
  • Dexter Industries for giving me a GPS sensor

You can download it from the usual spot: [LINK].

Written by Xander Soldaat

November 11th, 2010 at 9:58 am

Posted in General News

Tagged with ,

Traversing a Grand Challenge with the VEX Cortex

without comments

The Grand Challenge is a staff designed course which is not revealed to participants until the day of the competition. Before the competition, participants are provided with a list of conditions and situations to prepare their robots for.

On the day of the competition, the participant’s programming knowledge and preparation are put to the test as they work to traverse the course in a limited amount of time. The robot that makes the most progress without stalling out or deviating from the course wins!

In this iteration of the Grand Challenge, the Cortex-based robot must:

  • Navigate an obstructed path using feedback from the Shaft Encoders and Ultrasonic Rangefinder
  • Track an incomplete line up and down a ramp using feedback from the Line Tracking sensors
  • (Optional) Pick up the yellow ball and take it to the finish zone for extra points
  • Respond to remote-control commands only in the final zone
  • Avoid hitting obstacles in it’s path, walls on the field, and falling from the ramp

Check out this cool video of the robot completing the course.

To accomplish it’s task, the Cortex-based robot is equipped with:

  • Two driving motors, each with a Shaft Encoder
  • An Omni-wheel acting as a rear-caster wheel
  • Three Line Tracking Sensors
  • An Ultrasonic Rangefinder
  • Remote Control over VEXnet

Instructions for building this robot can be found here.

If you’d like ideas for creating your own Grand Challenge, check out this document for some inspiration.

Note: All materials are part of the VEX Cortex Video Trainer. Check it Out!

Written by Jesse Flot

November 3rd, 2010 at 10:40 am