Archive for November, 2010
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!
The source code for this robot will be part of the next release of the ROBOTC Driver Suite.
Original post here: [LINK].
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!
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.
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…
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:
I’m open to any questions or suggestions for improvement.
Part 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.
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].
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…”
WELL YOU’RE IN LUCK!
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:
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
- BLUE = SUBTRACT
- YELLOW = MULTIPLY
- WHITE = DIVIDE
The LEGO Color sensor will read the colors and convert them to numbers or operations after the user inputs numbers and operator as follows:
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:
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 firstname.lastname@example.org.
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!
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.
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 !!*//
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.
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.
- 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].
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
- 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!