ponting

dhoni in icc t2o world cup

contraption ideas

Ideas:

Lifts:

Chain lift: continuous chain with “buckets” that lift balls one (or more) at a time. Can act as a clocker, delivering balls in a continuous measured rate. Can deliver vertically.

Conveyor: moves balls up incline (or horizontally). May use idler wheels/gears to change shape of path. To insure feeding from hopper, “bumpers” or “sweeps” might be used to stir the hopper.

chain-based: continuous chain drive, with “paddles” or blades that sweep balls from input hopper to top. Can grab more than one ball (depends on width of conveyor). Small footprint, input hopper geometry critical.

belt-based: series of overlapping tank tread belts lift balls up shallow inclined path, with perhaps axles or other small thin parts keeping dumped balls from being pinched or spun between consecutive belts. Probably limited to very shallow slopes.

custom belt [SMART]: wide belt of frictionless-pin-linked studless beams carried and driven by various tires instead of gears. Heavy, wide, but novel.

multi-bladed/propeller [SMART]: series of rotating blades projecting thru the conveyor floor, such that the first rank of blades lift the balls up & forward, and as they rotate back down the second rank of rotating blades continues the process.

roofed: smooth sloping floor of conveyor just holds balls against moving roof that pulls balls up the passive floor. Feeding may be a problem (perhaps from side, not end of belt). Maximum angle uncertain.

tank-tread roof: Balls “roll” up floor ramp at half the speed of the belt, rolled by the moving roof above. May be limited to single tank tread length (belt-to-belt feeding unsolved).

custom or link-based roof: moving roof uses hanging “scrapers” to snag balls in a pocket or cell, dragging them up the ramp.

Marble pump: reciprocating piston lowers a ball from the hopper and pushes it into the output stack above. Limited by the weight of the stack above (“tube” above must resist bursting due to column weight, piston must have enough force to lift entire column). Ideal for clear side to show pump mechanism, but may weaken. Requires priming, and draining ability (when hopper runs out, column above pump is inaccessible). Can function as a clocker

Ferris wheels [SMART]: rotating series of cages, sweeping in a ball at the bottom (unsolved) and dumping them out at a high platform that tips cages. Can function as a clocker, requires a wide footprint.

ferris lock: the idea is to use a long tray or “stretched cage” attatched to a wheel or large gear. It can scoop at the bottom of the cycle, and dump into a linear tray or chute at the top (lifts half a cycle, or one diameter, assuming non-pivoting tray with three sides (only the roof open)), or it can rise from under a bin and tip out near the top (lift only 1/4 of circle, assuming non-pivoting tray)

clock lift [Steve]: picture a slightly tipped-back clock face, with a “C” shaped cup on the end of the minute hand. At the bottom (“6 O’Clock”) it scoops a ball (or balls) into the cup from a bin, rotating them up the face of the clock. Near the top (say between 11 & 12 O’Clock) the face is cut away, allowing the balls to fall out and into a chute or receiver.

wheel lift: based on the Hailfire Droid wheels, wheel lays in a slightly inclined cavity with the bottom a shallow trench to lower the inner rim level with the attatched hopper floor. At the top of the cavity the rear wall is missing, allowing balls to roll out of the open cells attatched rigidly to the wheel’s inner rim. Wheel can be rotated by resting it on regular driven wheels on the inner border of the cavity. A second wheel can be used as a 2nd stage, set above and just behind the lower wheel/cavity assembly.

Shooter: two high-speed counterrotating soft wheels grab ball and launch it upward. May require a cloker to make sure mechanism isn’t swamped by too many too fast, and feeding into the wheels could be tough. Height of throw may vary, but angle need not be dead vertical, and a high catchbasin could collect balls at the top. Difficult to ensure no dropped or lost balls, consistancy could be difficult as well.

door-spanner: toss balls one by one over the entry door to the room, catching in a larghe catchbasin (perhaps a fabric sheet funneled down toward the lower end).

juggler: more than one throwing device going to one or more catchbasins, with the possibility of interleaved streams.

spanner: balls thrown over a perpendicular module stream

Gantry crane [SMART]: grabbing claw on a static gantry can travel and descend to pick up entire crates of balls at once, moving them to a high ledge (or between one or more ground stations). Might, if high enough, allow a stream of modules to run under it.

cable-car: grasping crate claw drops from a wire-riding cable-car. Could cover large distances quickly, although maximum lift weight is likely low, and tension in the cable (metal wire) needs to be high (firm anchors, non-LEGO, likely needed).

Arm: “standard” arm that can grab a crate, lifting it and placing it somewhere else. Lots of variations

crate [SMART]: two gripping fingers (horizontal to grasp sides of crate, or vertical to grasp top & bottom edge of crate) close on crate and lift it off the surface before either roating it to a new location (onto an elevator, for instance), or rotating at the wrist to dump it into a hopper.

single ball: Two fingers can pick out a single ball

multible linkage: using a parrallelogram linkage, an arm could grab a crate and lift it to a much higher level while keeping it level, depositing (or dumping) it in a high hopper.

Archimedes screw: Possible shallow lift mechanism (are worm gears too small?)

Wind lift: use a fan/centrifugal fan/compressor to generate a strong airflow that can either entrain balls up a sloping ramp or even up a vertical shaft. Two issues: (1) making a powerful enough LEGO fan (or using a non-LEGO fan) to get the airstream, and (2) making sure that the “lift column” never becomes so saturated with balls that it collapses (either time the balls, or better yet only lift a new ball when an old ball has fallen out.

Scissor lift: flat platform on a scissor lift, dumping platform (with hopper/crate) at top as outer edge of platform catches under a lip. Ideal for pnematics.

Step feeder: series of vertically oscilating ledges or steps, each just a little bit higher than its neighbor and only as wide as a ball (or slightly less, actually). The first step lifts a part (ball) out of the bin, and at the top of the lift the ball rolls onto a static step with another moving feeder step on the other side, which repeats the process. Steps can be driven by cams on a central drive shaft at the base (or partway up).

single-acting: odd-numbered steps oscilate up & down syncronously, while even-numbered steps are stationary (passive “holding pens”). Since all the moving steps are syncronous, they can all be part of one structure, moved by a cam at the base (this is how toys, such as the “Playful Penguins”, often work)

double-acting: every step moves up & down, with alternate steps 180° out of phase, potentially much faster.

Elevator: single “mounted” crate that can be raised and lowered along a single path. A feeder ramp can dump balls into it: when the elevator is lifted, it can flip back the edge of the ramp, temporarily impounding any oncoming balls. The descending elevator restores the ramp and the flow of balls. At the top, the crate could be emptied in several ways:

trap doors: or suddenly exposed sides. Make one side of the crate a hole, blocked only by the wall of the elevator shaft; at a certain level (perhaps selectable) the shaft has a gap in the wall, spilling the balls.

dumpable: at the top of it’s travel, the crate is mechanically dumped, possibly be “tripping” on an edge at the top, for instance.

There are also at least two ways to drive it:

cable-based: a string (or perhaps chain links) pull the elevator up and down the shaft

cog-based: either an externally-driven gear cranks up & down a rack on the side of the elevator car (suitable for short drops only, unless you want a long rack sticking out), or the elevator car itself has a motor-powered gear that engages a static rack fixed to the elevator shaft.

Check valves: use some sort of check valves along a linear track to allow episodic pumping (perhaps be tipping the trough, or moving the roof or floor up & down or forward & back repeatedly). Requires only limited travel of the pumping mechanism, depending instead on the check valves (beams that fold one way but not the other?) to retain the balls in each compartment after a single pump cycle. Swinging gates made of axles, that fold one way but are blocked the other, would be ideal, as they could interpenetrate yet not let balls through.

Rake:

Water-wheel driven: a faling or descending stream of balls turns a paddlewheel, which in turn runs a small lift (like a chain lift or Ferris wheel lift) to pull a few balls out of the stream and raies them again for more processing.

Ramps: mobile carriers like dumptrucks or forklifts might ascend ramps before dumping or tipping their crates, allowing unloading at a higher level. Does require rather wide ramps if vehicle turns at top. Backing down after delivery might be easier, using guiderails on ramp instead of line-following, but will still require a significant ramp.

Widgits:

Ramps/chutes: Made from two upsidedown 1xn technic beams seperated by a short studless beam(this can be used to join two sections of chute as well). When guides are needed (such as when dropping a beam height, or dropping and turning 90°) beams can be pegged on the outside to “raise a rail” (with 1/2 pins in place the area between two rails can be narrowed by a tile on each side, perfect spacing to guide the balls into the center of the downstream chute). Lightweight & part-efficient.

Funnel: made from four “bowl corners” like in set #3433 NBA Arena, balls can be injected tangently, allowing them to orbit the funnel until dropping into the center drain hole.

Ski-jump: balls are jumped into the air off a gravity-fed ramp

Loop: balls run down a track to gain enough speed to go through a loop or two, like a rollercoaster.

Trampoline: airborn balls bounce off a hard flat surface to the next element. Ball stream will have to be clocked (or at least spaced), and surface to bounce off of must be very ridgid (little or no energy loss).

Sorters [SMART]: device that takes a mixed stream of balls and seperates them into soccer & basketball streams. To a light sensor, a spinning basketball is fairly uniform, while a rotating soccer ball should oscillate bright-dark. If the entire contraption uese only soccer balls, a sorter at the end could seperate out basketballs to keep them contained in a single module.

mixers: mixes together two or more incoming streams of balls. This could be passive (just add the two streams together; combiner) or active (drop both streams into a single hopper that is well-mixed, from which a homogenized stream can be sourced).

Overflow routes & bank storage: in case the ball stream can’t be processed fast enough (like by a sorter), an overflow route could be provided that by-passes or stores the excess until it can be precessed.

Pegboards: balls can be dropped into an isometric (triangle-based) array of pins, forming a binomial distribution at the bottom. Loud, fun, and allows a certain percentage to be siphoned off from one of the outer bins if desired.

custom boards: instead of a simple array of pins, balls roll down an inclined baseplate (32x64, for instance) that can be replaced with other, custom-made baseplates. This would allow spectators to design a portion of the mechanism, with the balls collected in a trough at the bottom.

Flip-flops: A device that shunts successive balls down alternate streams. A simple example is a “Y” shaped pivot, where the stem of the “Y” points up. When a ball is deflected off one of the arms on its way down, it tips the stem to the other side so the following ball is deflected off the other arm, reseting it.

digital logic: it might be possible to make digital devices, such as OR, XOR, AND, etc. Synchronization might require a “master clock”, with one or more balls cascading down an independatn series of chutes to “trigger” the gates.

Train [SMART]: loading & unloading traincars with crates of balls(via arms, cranes, etc.)

Land monorail: lacking trains, how about a wheeled car or truck, that travels over a “rail” of 2xn bricks to guide it, just running back & forth over a straight line. Stopper blocks at the end could signal loading and unloading, or stations mid-line could be signaled by the color of the central rail. Could function as a train (carrying crates) or have specially designed hopper that can dump on command (like a coal car or a log carrier).

Flatbed truck / landtrain: use a flatbed truck (or series of them) to move crates around. Truck could be loaded & unloaded via arms, forklifts, etc., or even gravity-feed loading might be a possibility.

Dumptruck [SMART]: A robotic line-following truck that could pull under a hopper (like a coal car loader) to recieve a load of balls, then proceed somewhere else to dump them (or elevate the entire bed and then dump, higher).

Forklift: line-following forklift that can lift and move crates, controled by barcodes along route (for ease of re-structuring the route, as well as possibility of dynamic control by changing barcodes “on the fly” - a hopper along the route could signal it needs service by deploying or changing a barcode along the route). Loaded crates could be “pushed” out of position by forklift delivering a new empty crate (with the newly released “full”crate then being picked up), or “full” crates could be pulled out allowing a new empty crate to slide down a ramp into position.

tilters [SMART]: slides forks under a crate, tilting forks up slightly to lift

lifters: forks can be raised vertically to lift crate a little or a lot. Crate could be placed on a high platform that could firmly catch then rotate to dump the crate (dumping could be “pushed” by raising the forks to push on a mechanism, with platform/crate returned to neutral via gravity).

dumpers [SMART]: forks lift, then at the maximum height rotate or tilt to dump crate

warehouse: a defined area for racks to hold multiple crates, with the forklift either “looking” for crates it needs (perhaps empties to the left, full crates to the right) or remembering where crates of interest are located.

Clockers/Smoothers: mechanically time the release of balls in the stream, limiting it to one per second or some similar, fixed rate. These can “smooth” an input stream, taking an episodic (crate-dumping) stream and making it uniform.

chain lift: a simple timed lift, one ball at a time

revolving door: as a rotating device turns, it can only grab one ball at a time (in a gap in the wheel) to release. Probably works better with the rotation axle oriented horizontally (either the gap acts to grab and lift over the wheel one ball, or with a series of two offset wheels a “chopper” mechanism breaks the stream into one ball units), not vertically as with a true “revolving door”.

choppers [SMART]: arms oscilating much like a mechnical leg can segment the ball stream into one-ball units.

balance-based: used in some wooden marble machines, the first marble triggers the release of the next after a certain time (as it goes down-run). A weak example would be a slightly tilting chute (or linked chutes), such that when the lead ball rolls off the far end the chute tips back, re-aligning with the feeding chute to allow another ball into the mechanism. As the new ball enters the mechanism, it tips the lead end of the chute up slightly, blocking any marbles behind from entering the mechanism.

Counters: keeps a running tally of some type of the balls running through the mechanism

mechanical: clockers have the nice property of delivering one ball at a time, allowing ball-counting either via timing (mechnism moves this long must deliver this many balls) or a purely mechnical means like that used in the rolling ball clock (filling & thereby overbalencing a tray, dumping the balls and passing a single ball onto the next ramp or tray. this can be cascaded down any number of levels).

digital: balls might be counted digitally via interrupting a light sensor (although consecutive balls might be a problem if a clocking mechanism isn’t used). Sorters can essentially do this as a by-product, as they need a digital knowledge of the number of balls anyway.

Log flume: long runs of a single ball stream. Ideally these should be along two rails or with only two points of contact. This requires either thin rails (plates with handles work well), or a 90° flume tilted so that it is “point down” (difficult geometry)

Air-suspended: a ball could hover in a rapidly ascending stream of air, possibly even allowing a series of balls to occupy the spot (incoming ball knocks the hovering ball to the output chute). Requires a good fan or other airstream.

Ben’s racetrack: Use the car tracks as guides for large number of balls, for rolling down slopes or perhaps even jumps. A small motorized vehicle could even run around a loop of track,plowing the balls ahead of it to a gap in the track where the balls fall off.

Roadplates: these can serve as large flat areas to collect marbles, or serve as bins (see gabage collecting below) or wide marble runs.

Garbage collecting: balls are dumped wholesale into an enclosed arena or field, where a mobil ball-harvesting robot scoops them up, delivering then periodicly to a waiting hopper (or crate).

Turntable scrambler: balls are dropped near the center of a rotating turntable, to be flung off by the rotation. Potentially turntable could be large (baseplate) and have a series of obstacles on it

Crate options , output (things to consider in a Type 2 standard): In order that no balls are spilled, there needs to be consideration given to how to “swap crates” at an output. Some options:

Crate pushing [SMART]: An empty crate is pushed into an active output zone, displacing the previously filled crate, which can then be safely picked up.

Gravity-driven crate feeding: Active output zone is at the end of a sloping ramp filled with empty crates. When the crate in the output zone is removed, a new crate from the feeder ramp will slide into position.

Triggered hopper: High hopper is filled by the output stream, with a trap door in the bottom (or side) that is only opened if a crate is present in the output zone. With a normally empty output zone, balls accumulate in the hopper until a crate is placed in the cradle, which opens the trap door filling the crate all at once. When the crate is lifted again, the trap door closes & resumes accumulating balls.

Impounding ramps: Output zone with a crate is fed via a ramp with a flip-up edge. When a crate is lifted the edge is tipped back, temporarily impounding the incoming ball. After a new crate is placed in the output zone, the edge of the ramp flips back down, releasing the impounded balls and resumes filling the new crate.

Stackable crates: A fresh empty crate is placed above the current active crate in the output zone. Some mechanism (yet to be determine :-) ) then removes the lower crate and lowers the upper crate into the output cradle.

Crate options, input : Forklift raises crate into a high rotating cradle. The forlift then pushes up on the back of the cradle, rotating it forward and dumping the balls from the crate. The crate can then be removed to be reused.

Hopper busters : Even if the lift mechanism works reliably, the hopper feeding it has a tendency to jam. Smooth & non-narrowing would be best, other options:

tippers: slowly change the angle of the hopper to clot-bust

bumpers:make one or both walls of the hopper move in or out at least slightly to clot-break

shakers: repeatedly shake or bump the entire hopper to clot-break

stirrers: use a blade from below or above to stir or mix the hopper, clot-breaking

robotics projects 1

from: http://www.robotshop.com/gorobotics/robotics-projects( for videos visit this site)

Carlitos’ Projects: Speech-Controlled Arduino Robot

Posted on March 1st, 2011 in Microcontrollers, Projects, Robotics Projects, Robots

We all dream of having appliances and machines that can obey our spoken commands. Well, let’s take the first step towards making this happen.  In this second iteration of Carlitos’ Projects, we are going to build a speech-controlled Arduino-based robot.

You may be thinking that making such a robot must be a very complex task. After all, humans take many years before they can understand speech properly. Well, it is not as difficult as you may think and it is definitely lots of fun. The video below illustrates how to make your own speech-controlled Arduino rover.

After watching the video, read below the detailed list of parts and steps required to complete the project.

Materials

• A DFRobotShop Rover kit. It constitutes the robot to be controlled.
• A VRbot speech recognition module. It processes the speech and identifies the commands.
• Two Xbee RF communication modules. They create a wireless link between the speech recognition engine and the robot.
• An Arduino Uno. Controls the speech recognition module.
• An IO expansion shield. Allows to connect the Xbee module to the DFRobotShop Rover
• An Xbee shield. Allows to connect an Xbee module to the Arduino Uno.
• Male headers. They are required by the Xbee shield.
• A barrel jack to 9V battery adaptor. Allows to power the Arduino Uno trough a 9V battery.
• An LED. It is not required since the IO expansion shield already has one but it can provide a more visible activity feedback.
• An audio jack. It will be used to connect the microphone. This is optional
• A headset or a microphone (a microphone is included with the speech recognition module).

Tools

• A Wire Cutter. It will be used to cut the leads off components.
• A Soldering Iron. In order to solder all the (many) connections, a soldering station might be preferable since it provides steady and reliable temperature control that allows for easier and safer soldering (you have less risk of burning the components if the temperature is set correctly).
• A Third Hand. This is not absolutely required, but it is always useful for holding components and parts when soldering.
• A Hot-glue gun in order to stick the components together.
• A computer . It programs the DFRobotShop Rover and the Arduino Uno using the Arduino IDE.

Putting it Together

1. Assemble the DFRobotShop Rover and mount the IO expansion shield, an Xbee Module and the LED. Se the picture above or the video for further information.
2. Solder the headers onto the Xbee shield. Also solder four headers on the prototyping area as shown below. Do not like soldering? Then keep reading since there is no-solder-required version of the project.
   
3. Connect the four headers to the corresponding pins as shown below.
   
4. As shown above, you can also mount the headphone jack and use the cable included with the microphone in order to connect it to the VRbot module microphone input.
5. Put the shield onto the Arduino and connect the battery.
   
6. Connect the VRbot speech recognition module wires and the microphone.
   
7. Program the DFRobotShop Rover and the Arduino Uno with these programs respectively:
   dfrobotshop_serial.zip and VRbot.zip
8. Start talking to your robot! Say “forward”, “backward”, “left”, or “right” in order to make the robot move in the desired direction. The word “move” shown in the video has been removed from the program in order to improve the performance.

Go Further

Now that you have the basic program you can create new commands in order to build upon this project. For instance, it would be nice to program a “dance” command that would make the rover execute a predefined choreography. It is also possible to use this knowledge to control other devices such as lamps, TV sets, and more.
You can find more information about using the VRbot speech recognition module here:

• Veear Arduino Demo
• Arduino Demo program

In our case, we used two of these robots in order to create a ball-fetching challenge at the CRC 2011 with high-school and CEGEP students. As shown below, the students and general public loved the game.

Get your own

RobotShop put together a full kit that you can buy in order to get started with speech control. This kit is a bit different than the project shown and does not require any soldering and uses the microphone included with the VRbot module:

DFRobotShop Rover – Speech Control Kit

Share the robot goodness:

• 
• 
• 
• 
• 
• 
• 
• 

16 Comments »

Carlitos’ Project: RGB LED Mood Cube

Posted on January 14th, 2011 in Microcontrollers, Miscellaneous, Projects, Robotics Projects

This is the first in a series of electronic or robotic DIY projects. These projects are accompanied by instructional videos that will help you trough the many steps involved in completing the task at hand. For this first iteration, we are making an RGB LED Mood Cube.
Glowing colour-changing objects are always cool. So why not make your own? Mood lights have been around for some time and, while it is cool to have a colour changing light, it would be even cooler to have something more complex and geekier. An RGB LED Mood Cube seems to be the way to go.

In this project, we are going to build a 4x4x4 RGB LED cube that can be used to display cool colourful patterns. This project should be straight-forward and the most significant difficulty will be soldering all the connections for the cube structure and the 64 LEDs (since they are RGB, this means 256 joints for the LEDs alone!). In short, if you are looking to have a cool mood-light and get razor-sharp soldering skills, this is the right project for you.
Below you can see the video of the LED cube being put together and the final result.

If you need more information or you simply prefer written instruction, here you will find the full list of materials, tools, instructions and documents required for the build.

Materials

• An LED Cube Kit. Provides the LEDs and all the structure required to create an LED cube.
• A Rainbowduino. It is a special Arduino built to control up-to 192 LEDs.
• A UartSB (USB-to-serial adaptor). A USB to serial interface that is used to program the Rainbowduino (or for serial communication in general) trough a USB port.
• A USB Cable. A cable to hook-u the UartSB to the Computer
• A 9V Wall Adapter. A power supply that will power the cube once the assembly and programming are done.

Tools

• A Wire Cutter. It will be used to cut the leads off components.
• A Soldering Iron. In order to solder all the (many) connections, a soldering station might be preferable since it provides steady and reliable temperature control that allows for easier and safer soldering (you have less risk of burning the components if the temperature is set correctly).
• A Third Hand. This is not absolutely required, but it is always useful for holding components and parts when soldering.
• A Flat Head Screwdriver. This will be used for un/tightening terminal blocks
• A computer . It programs the Rainbowduino using the Arduino IDE.

Putting it Together

1. The first step is to assemble the LED cube kit. This kit is much easier to put together than the more common way of constructing an LED cube using the LED leads as the supporting structure.
   The kit includes all the parts required to hold the LED together and takes care of all the complex wiring. Full instruction on how to put the cube together are available in PDF format.
2. Once the cube is assembled, we need to drive it in order to display cool stuff in it. For this, we use the Rainbowduino, an Arduino clone created specifically for driving massive amounts of LEDs. The cube fits directly on top of the Rainbowduino, and can provide power to it by using the included JST cable. When connecting both modules together, it is important to make sure the “Green” male headers from the LED cube match the “Green” female headers on the Rainbowduino. Also, it is important to set the Rainbowduino switch to “JST”.
   
3. Now that all electrical connections are done, we need to write some software in order to make it display cool stuff in our new cube. We took the liberty of modifying, cleaning and updating the plasma code readily available for the Rainbowduino. This new code should display a nice smooth wave as of colours that propagates softly though the cube. The code can be downloaded from here: Rainbowduino-RGB-LED-Matrix-Plasma.zip.
   In order to upload this code to your Rainbowduino, you will need to use the Arduino software, so, if it is not already done, it has to be installed. Also you will need to install the USB-to-Serial adaptor drivers.
4. Once the code and the Arduino software are downloaded and installed, simply unzip the code and open the .pde sketch file found inside of the unzipped folder using the Arduino software. Then, upload the sketch to the Rainbowduino using the USB-to-serial interface.
   
5. Now that the Rainbowduino is programmed, simply remove the USB interface, plug-in the power adapter and admire the light show!
   

Additional Programming and Hacking

Of course, colourful lights are pretty and everything, but for those of you who would like to program your own patterns and animations, there are functions in the provided code that allow you to set the LEDs individually. You could also add some sensors and make the cube interactive. There are even some Xbee headers that could be used to send information to the cube remotely from a nearby computer Using an Xbee module.

On the physical side, you can make a cover for your cube out of paper, plastic, fabric or whatever other materials you have on hand (make sure the material is translucent though)
Finally, at the end of the construction, you will have many RGB LEDs and a bunch of male and female headers left-over. Make sure you put them to good use in your next project.

Getting Your Own LED Cube

For those of you wishing to make their own cube, you can use your own parts and buy the missing materials separately or you can get all the components in a convenient kit at RobotShop.

You are also invited to share your results and experience in the RobotShop Forum and by simply leaving a comment below.

Share the robot goodness:

• 
• 
• 
• 
• 
• 
• 
• 

5 Comments »

LEGO Robotic Projects

Posted on September 24th, 2010 in Robotics Projects

If you want  be able to design, build and program complex autonomous robots but have limited experience and don’t know where to start, LEGO Mindstorms is perfect for you!
In the video below you can see one of Menno Gorter’s LEGO Creations:

LEGO has developed one of the most intuitive, easy to use programming software on the market today. Gone are the nuances and painstaking time to debug and check your code, replaced with a visual interface, similar to a LEGO modular brick structure.

Versatile LEGO TECHNIC elements

LEGO has expanded its range of classic bricks to include gears and complex parts to let your imagination run wild. This can always be mixed with standard LEGO bricks.

State-of-the-art sensors and servo motors

Even the basic kit includes complex sensors which will allow your students to create complex autonomous robots.

Easy to use “drag and drop” programming software

Worried about complex programming? LEGO Mindstorms comes with an intuitive drag and drop user interface which allows your students to easily program the robot.

All of these connect to the NXT Intelligent brick

The NXT microcontroller is the brain of any MINDSTORMS® robot. It’s an intelligent, computer-controlled LEGO® brick that lets a MINDSTORMS robot come alive and perform different operations.

1. The NXT is an intelligent, computer-controlled LEGO brick and is the heart of any LEGO MINDSTORMS autonomous robot
2. The touch sensor enables the robot to feel and react to its environment
3. The sound sensor enables the robot to hear and react to sound
4. The light sensor allows the robot to detect light and colour
5. The ultrasonic sensor gives your robot the ability to see, measure distance and react to movement
6. The servo motors , which can be used for partial angle or continuous rotation, ensure your robot moves with precision.

The LEGO MINDSTORMS NXT software enables you to program your NXT robotic invention and upload your programs to the NXT via USB or Bluetooth connectivity. The intuitive Mac and PC compatible drag and drop software, powered by National Instruments LabVIEW, comes with building instructions and programming guides to easily begin constructing and programming with MINDSTORMS NXT.
Try the DEMO !
LEGO MINDSTORMS is a modular design system that allows you to creat almost any kind of robot.
LEGO provides detailed instructions as to how to build a variety of different robots. There are step by step graphical instructions to guide you through the building process.

What type of robots can you do?

Spike:

Spike reacts like a real-life Scorpion. It craws on six legs, has a set of pincer arms (pedipalps), can see and hear with ultrasonic and sound sensors, and can quickly “paralyze” its prey with a touch-sensor enabled stinger!
This simple program allows the Scorpion to move forward to a target, play a sound when it hits the target with its stinger, retract the tail again and go back to its starting point.

RoboArm T-56:

RoboArm T-56 is a sophisticated robotic arm that can lift, pivot, and grab objects with its claws. It can detect colors with its Light Sensor and feel objects with its Touch Sensor . Three Motors power RoboArm T-56 – 1 motor powers the grabber claws and 2 motors enable the robotic arm to move up, down, and turn!
This simple program gives RoboArm T-56 the intelligence to distinguish between a red or blue ball with its light sensor. It grabs and moves the red ball, but rejects and releases the blue one when grabbed.

TriBot:

TriBot is a flexible and fast 3-wheeled driving robot! It takes advantage of all four sensors to do the job you program it to do. TriBot can grab a ball when you give it a sound command (through its Sound Sensor ), can be programmed to follow a line with its Light Sensor , can feel objects with its Touch Sensor , and can see with its Ultrasonic Sensor.
This simple program enables TriBot to power 1 motor when the light sensor detects dark, and a second motor when the light sensor detects light. Use this program to have TriBot follow a line, modify it, or create one of your own!

Alpha Rex:

Alpha Rex performs tasks that only the most sophisticated robots can do… Walk on two legs like a real person! With built in rotation sensors on the two Servo Motors powering his legs, and an Ultrasonic Sensor enabling Alpha Rex to see, you can program Alpha Rex to go where you want with precision!
This simple program makes use of simultaneous tasks on two Sequence Beams. Alpha Rex’s heart beats on one task, while his legs are powered to move on the other.
Find even more project ideas on the official LEGO Activities website (School mindstorms), and see detailed instructions how to build a Classic Cuckoo Clock or Sound Bot .

New Robotics Projects Section

Posted on September 7th, 2010 in Robotics Projects In an effort to make robotics accessible to everyone, we will be posting robotics project ideas and guides. This will provide you some inspiration to start using your newly acquired skills from the How to Make a Robot Tutorial Series.
Stay tuned for new projects to come. In the meantime, you can check out the RobotShop Learning Center for some cool Project Ideas.

topics for paper presentation

from:http://vanishd.wordpress.com/2008/04/17/topics-for-paper-presentation-mechanical-engg/



Considering the large amount of searches for good paper presentation topics which people seem to be making, here are some which i have come across in recent reading. Also a list was put up in our college, i picked up a few interesting ones from them…

• Magnetic Refrigeration
• Modern Refrigeration Systems: Solar, Thermionic, Vortex Tube…
• Intelligent cars
• Formula 1 cars: Aerodynamics, Steering Wheel, Safety, Engines.
• Driver Assistant Systems
• ABS
• Electronic Stability Control
• LiGov
• Traction control
• Active Steering Control
• Rocket Booster Systems
• Camless Engine
• 6 stroke engine
• Supply Chain Management
• CVT
• Latest Suspension Systems
• Sky Bus
• Pressure sensitive paint
• Stratified Charge Engine
• Exoskeleton for human performance augmentation
• Pistonless rocket Engine
• Ion Drive Engine
• Automated highway systems
• Variable timing Valve Trains (VTVT)
• Maglev
• Rocket Propulsion
• Adaptive Light patterns for Automobiles
• Robotic Vision
• Ramjet, Scramjet
• Negative Pressure Supercharging
• Fluidised Bed Combustion
• Tiptronic Gearbox
• Vacuum Heat Treatment of Materials
• Dry Ice Blasting
• Quasi Turbine Engines
• Airbus A380
• Aircraft navigation Systems
• Magnetorheological Fluids
• Smart materials
• Lean Burn Technology
• Catalytic Convertors
• Exhaust Gas Recirculation
• Air Car
• Reaction Engineering

• Flexible Manufacturing systems
• Quality Function Deployment
• MRP I
• MRP II
• Enterprise Resource Planning
• Statistical Quality Control
• MEMS
• Rapid Prototyping
• Total Quality Management
• JIT
• Vertical Axis Wind Turbines
• Pendulum Pump technology
• TATA NANO – worlds most economic car
• Automotive Lighting
• Automotive suspension systems
• DI Gasoline – Stratified charge operation
• Non Conventional Manufacturing Technologies
• Ergonomics in Plant layout
• Ergonomic studies in Automotive seating – Vision and Suspension
• Tribological Seals – Principles, types, operation, pressure distribution, non contact seals, materials
• New Generation Integrated Roller bearings with wheel hub
• Daimler – Branch Information Center –  A forward step in Customer Management
• Bloom Box – Answer to our Energy woes?

line tracer with programming part2

from:http://www.roboticsindia.com/entry.php/183-Competitions-Robotics-3-The-Build-and-a-Fast-Line-Follower-using-PID


The above code is for a decently advanced line follower written by me over a Sunday evening. Most of the code comes from Pololu Documentation with some customizations for my Robot. The compiler is AVR-GCC being run inside AVR Studio.

The robot does self calibration based on environment to optimizes its sensor reading for line following, this can be seen in the video. Once calibrated it waits for user input to start.

There are basically two choices available -

void follow()

This is the simple line following function which just goes left and right based on the location of the line.

void followPID()

This is a PID based line following mechanism with some of my own customization to prevent robot from skidding. Please do optimize the code if you ever use it. The built robot is quite fast , but due to the small course we are not able to see the real speed.

For the documentation of functions and idea used please refer to the link below

Pololu QTR Sensor Functions

line tracer with programming part1

Competitions Robotics 3 - The Build and a Fast Line Follower using PID

If you are building this and already have bought the parts I will assume that you will need little help assembling it , but I would like to give some pointers so that you don’t make the mistakes which are usually made by people and things proceed fast for you.

Lets start with the PCB as it is the heart of your robot, the PCB files can be downloaded here.

Schematic and Board files in Eagle

Either get the PCB made by a PCB vendor or simply do it yourself using the Ferric chloride method ( tutorial ). This PCB is made for easy fabrication at home with all components available locally. Also this Board can easily be used for any of your own robots. And has been made with libraries compatible to orangutan so you have a good framework to fall back on.

We will first start off by assembling the electronic component and then in the end putting everything together. So starting out if you have made the PCB yourself you can TIN it yourself, doing it is quite simple and will stop your PCB from oxidizing. To do so simply put a small drop of Solder on our copper side of board and then rub it across using your hot solder head ( With Max possible temprature). This will create a very fine layer of solder on the copper.



Also you can print the top silk side on a paper cut it to size and paste it to make it look neater and to label everything.Next solder the components, start with the small ones and move to the bigger ones, this allows for easy soldering. Also use ample flux while soldering to get good joints.



To make FRC cables simply use a plier and put the cable in between it to make the connections, it works well. And with FRC cables you get a very neat robot.



So here is the final robot once again with the battery and the Orangutan Board from Pololu mounted on it -



Lets start moving –

Since we are using a framework and our PCB is built for it most of the things are already taken care of –

To move your robot forward for a second at speed 30 here is the code .

Code:

#include <pololu/orangutan.h>
 int main()
{
set_digital_input(IO_D4, PULL_UP_ENABLED);
while(is_digital_input_high(IO_D4)) {}    // Wait for user to press button
    red_led(1);                  // Indicate robot is ready
    delay_ms(1000);
    set_motors(30,30);  // Go straight 
    delay_ms(1000);       // 1 second 
    set_motors(0,0);       // Stop
    while(1) {} 
}

 

Now Lets do the hello world in robotics , which is line following , the code is self explanatory. If you need a introduction on PID please read here ( PID Tutorial ).

We are using the following line sensors as they give good price/performance. Other than that the allow for low ground clearance with minimal interference.

QTR-8RC Reflectance Sensor Array

Our Robot with Line Following setup -



The final robot



Now the Code - 

#include <pololu/orangutan.h>
  
unsigned char qtr_rc_pins[] = {IO_C0, IO_C1, IO_C2, IO_C3, IO_C4, IO_C5};
unsigned char qtr_rc_count  = 6;       
unsigned int  qtr_rc_values[6] = {0};

// Ideas is to keep line in the center 
void follow()
{
    int position = qtr_read_line(qtr_rc_values, QTR_EMITTERS_ON);

    int center = (( (qtr_rc_count - 1) * 1000) / 2);
    int error  = position - center;

    int leftMotorSpeed = 50;
    int rightMotorSpeed = 50;

    if (error < -(center/2) )  // the line is on the left
    leftMotorSpeed = 0;  // turn left
    if (error > (center/2) )  // the line is on the right
    rightMotorSpeed = 0;  // turn right

    set_motors(leftMotorSpeed,rightMotorSpeed); 

}


float KP = 3 ,KI = 50000 , KD = 16/1;

int   integral  = 0;
int   last_proportional = 0;

void followPID()
{
    int position = qtr_read_line(qtr_rc_values, QTR_EMITTERS_ON);

    int center = (( (qtr_rc_count - 1) * 1000) / 2);

    int proportional = position - center;

    int derivative = proportional - last_proportional;

    int power_difference = proportional / KP + integral / KI + derivative * KD;
    last_proportional    = proportional;
    integral  += proportional;


    const int max = 200;
    const int max_diffrence = 20;
    const int factor_diffrence = 2;

    if(power_difference > max)
        power_difference = max;
    if(power_difference < -max)
        power_difference = -max;

    
    // if diffrence is too much robot skids 

    int leftMotorSpeed  = max;
    int rightMotorSpeed = max-power_difference;

    if(power_difference < 0)
    {
        leftMotorSpeed  = max+power_difference;
        rightMotorSpeed = max;
    }


    if(leftMotorSpeed - rightMotorSpeed > max_diffrence)
    {
        leftMotorSpeed -= (leftMotorSpeed - rightMotorSpeed)/factor_diffrence;
    } 
    else if(rightMotorSpeed - leftMotorSpeed > max_diffrence)
    {
        rightMotorSpeed -= (rightMotorSpeed - leftMotorSpeed)/factor_diffrence;
    }

    set_motors(leftMotorSpeed,rightMotorSpeed);

}



int main()
{

    set_digital_input(IO_D4, PULL_UP_ENABLED);

    while(is_digital_input_high(IO_D4)) {} // Wait for user to press button
    
    qtr_rc_init(qtr_rc_pins,qtr_rc_count, 2000, 255);  // 800 us timeout, no emitter pin

    red_led(1);
    delay(1000);

    int i;
      for (i = 0; i < 100; i++)  // make the calibration take about 2 seconds
      {
        if(i%25==0)
        {
            if((i/5)%2==0) set_motors(20,-20); 
                else set_motors(-20,20); 
        }

        if(i%5)
        {
            if((i/5)%2==0) red_led(0);
                else red_led(1); 
        }
        qtr_calibrate(QTR_EMITTERS_ON);
        delay(20);
      }
 
    set_motors(0,0); 
    red_led(1);

    while(is_digital_input_high(IO_D4)) {} // Wait for user to press button
    delay(1000);

    while(1)
    {
        //follow(); // If you want to use non PID method 
        followPID();
    }}

}