Nearing the end of my journey through VEX SensorLand. Today I’ll discuss these little widgets that get plugged into the cortex: jumper clips and LED indicators. Not sure they exactly count as sensors, but they get plugged into the same place as sensors on the cortex. These items are like twin brothers from a fairy tale: exact opposites. Jumper clips serve as information coming IN to the cortex, and LED plugs are information going OUT from the cortex.

Compressed Table-o-Contents


The Components

VEX Jumper clip

Jumper clip
(Digital Input)

Jumper clips: $2.49 for a 5-pack (but if you look around your lab, you’ll probably find the ones that came included with your cortex).

VEX LED Indicator

LED indicator
(Digital output)

LED indicator lights: $9.99 for an 8-pack (3 green, 3 red, 2 yellow). Why only 2 yellow? No. Idea. (Do the math: translates into > $1 each.)

Installation

Uhhh….plug them in.

The orange jumper clip, as you can see from the image, is symmetrical—if you flipped it over it would look just the same, so it doesn’t matter which way you plug it in.

The LED indicator, on the other hand, is not symmetrical; it has only 2 pins, and has the little plastic tab on the plug (like motor controllers & extension wires) so that you can only plug it into the cortex in one orientation. If you’re plugging the LED into an extension wire, the 2 pins match up with red & white on the 3-wire extension (the black wire is not used).

Both the jumper and LED get plugged into the cortex’s Digital ports.

Jumpers and LEDs are From Backward-Land

These items work exactly the opposite from the way you’re likely thinking.

For jumper clips, if the port is empty, it returns a 1 (HIGH); if the port has a jumper, it returns a 0 (LOW).

For the LEDs, if you want to turn one ON, you set that digital output to 0 (LOW); if you want to turn it OFF, you set that output to 1 (HIGH). (See below for RobotC variations on this.)

Jumper Clips

In competitive robotics, jumper clips are for the most part used to select an autonomous routine before a match. Set up your autonomous code to say something like, “If there’s a jumper in Digital3, then run autonomous pattern xxx”; “Otherwise, if there’s a jumper in Digital 4, then run autonomous pattern yyy.” In this regard, jumper clips serve the same function as an LCD screen, but don’t cost $50. In fact, you probably already own some clips, as they come included when you buy a cortex.

Set up each autonomous pattern as a separate function in your competition program, and then your whole auton code would be something like:

function AutonXXX () {
   make robot do stuff here
}

function AutonYYY() {
   make robot do different stuff here
}

function AutonZZZ() {
   make robot do some basic movement that will work
   no matter where you start, in case you forget to put
   the jumper in, or put it in the wrong slot
}

autonomous () {
   if Digital3 has a jumper (Digital3 equals 0) {
      AutonXXX();
   }
   else if Digital4 has a jumper (Digital4 equals 0) {
      AutonYYY();
   }
   else {
      AutonZZZ();
   }
}

The main difficulty here is that these clips are VERY small, and the cortex is probably somewhere in the middle of the robot, with a whole lotta wires coming out of it, and it’s very hard to see what’s what. So the danger is putting it into the wrong slot. One way to lessen that likelihood is to use slots that are NOT next to each other, as is written in the example above. Use ports that are at opposite ends of the cortex, or ports that are separated by other stuff already plugged in, like so:

Port Purpose
1 jumper for AutonXXX
2 bumper switch
3 potentiometer
4 jumper for AutonYYY

One clever team I read about on the VEX Forum put an extension wire into each port where a jumper might go, and ran them a little way from the cortex. They labeled the end of each extension wire “Port ##” (or, alternately “AutonXXX”), so that it was abundantly clear which jumper clip was supposed to be plugged in. This setup has the added benefit of every team member *not* having to remember which program is for which port, and makes last-minute changes a little more foolproof.

For teams that have *MANY* autonomous programs, a bank of several extension wires can lead out from the cortex, and using a combination of jumpers can achieve a large number of possibilities. Three wires can produce 23 possibilities:

Program Jumper 1 Jumper 2 Jumper 3
Defaut      
2 x    
3   x  
4     x
5 x x  
6 x   x
7   x x
8 x x x

A bank of 4 wires offers 24 options (16 possible programs). This is a great opportunity to teach your students binary code! As one might imagine, such a setup requires very clear labeling of wires, and a cheat-sheet accessible to all team members in the pit area as well as at the field.

Jumpers aren’t for auton selection only. If you’re in your lab and want to try any type of either/or testing, or run different joystick programs, or try out different combinations of joystick controls, you can use jumpers as a way to quickly switch between programs without having to download again. As above, keep close track of which jumper controls which functionality. In fact, you might even want to write it down in your engineering notebook…..

easyC Programming

In easyC, in your configuration window label the ports (Digital 1 & 4, from the table above) with some useful description, like “jumper for AutonXXX”.

In your program, you’ll use the GetDigitalInput() function, just like for a bumper switch.

autonomous() {
   jumper1 = GetDigitalInput(1);
   jumper4 = GetDigitalInput(4);
   if jumper1 == 0 {
      AutonXXX();
   }
   and so on from above

RobotC Programming

In RobotC’s Motors & Sensors setup window, set Digital ports 1 & 4 (from the example in the table above) to “Digital In” in the dropdown menu.

Your program would look something like:

autonomous() {
   jumper1 = SensorValue(dgtl1);
   jumper4 = SensorValue(dgtl4);
   if jumper1 == 0 {
      AutonXXX();
   }
   and so on from above

LED Indicators

As mentioned above, the LED doo-dads are OUTPUTs, because the cortex is sending instructions OUT (e.g., “Hey you, in port #4! Turn on that light!”). So, the LED port must be configured as an output. After that, it’s mostly the same as above: 1 (HIGH) = do nothing; 0 (LOW) = turn on LED.

Many teams use these little lights for debugging their programs, as a more-limited version of an LCD screen. You could set one of them to turn on when the program enters a certain part of the code, or set the red one on if XXX and set the yellow one on if YYY.

I really wish that these came in colors that were not EXACTLY the same as the 3 lights already on the cortex. From far away, it’s difficult to see whether the light you’re looking at is an LED or a cortex status light.

In Starstruck, my team ran 3 green LEDs from the cortex on extension wires and zip-tied them to 3 different sides of the robot. When auton code was not yet selected from the LCD menu, the lights flashed green. If an auton pattern had been selected, the lights were dark. The idea was to make them visible to the drive team before a match started, no matter how the robot was positioned, so that everyone could help make sure that code was selected properly.

LEDs in easyC

In easyC, in the configuration window, make sure that the little arrow is pointing OUT from the circle, and label it something helpful, like “green LED”. To turn on or off the LED, use the SetDigitalOutput( portNumber , ## ) command, where the first argument is the number of the port with the LED plugged in, and the second argument is  either a 1 (off) or 0 (on). Examples:

   SetDigitalOutput( 4, 1 );   // turns OFF the LED in port 4
   SetDigitalOutput( 6, 0 );   // turns ON the LED in port 6

LEDs in RobotC

Interestingly, LEDs are more confusing in RobotC than easyC. You can set them up in your Motors & Sensors setup window as either a “VEX LED” or a “Digital Out”. And unfortunately, they work exactly opposite to each other, as shown here.

RobotC LED Indicator setup
Handy-dandy RobotC LED reference chart:

Action Set up as LED Set up as Digital Out
LED on SensorValue[LEDname] = 1; SensorValue[LEDname] = 0;
LED off SensorValue[LEDname] = 0; SensorValue[LEDname] = 1;

♦           ♦           ♦

If you can believe it, that’s all I have to say about these items.


Other Sensors

Here’s a list of all of the sensors in my review:

Share this post: