Guerrilla guide to CNC machining and resin casting

1. Introduction

2. Prefabricated element library

2.1. Let's talk bookkeeping

• Stock materials: keep a basic inventory of resins, prototyping boards, pigments, and other specialty consumables. Write down manufacturers' product numbers to make it easier to restock (particularly important for pigments - all 15 shades of pink look very much alike). You will also likely find it useful to write down key characteristics of the resins: pot life, Shore hardness, flexural strength and modulus, mixing ratios, and any additional application notes - it beats scanning through individual product datasheets over and over again. Here is an excerpt from my list (invent your own cryptic abbreviations as needed):

    Name              | Dsty | Visc |    Mix | Pot | Hrd | Flx | FMd | EaB | Amt  | Notes
   -------------------+------+------+--------+-----+-----+-----+-----+-----+------+-------
    IE 3075           | 1.11 |  300 | 100:89 |   8 | 80D | 120 | 2.9 |   8 | 4 kg | MDI
    OC 7086           | 1.10 |  650 | 100:57 |  17 | 80D | 110 | 2.4 |   8 | 4 kg | HMDI
  

• Cutting tools: create a list of all the cutters in your collection. This really matters. Include geometry data: tip shape, mill diameter, corner radius, cutting length, reach, total length, and so forth. Also write down manufacturers' product codes and quantities, so that you know when to reorder, and never end up having to postpone a project for two weeks because you managed to break the last cutter capable of machining some particular detail - or worse yet, end up with a geometry that simply can't be made at all with the tools available on the market. Be pedantic and try to keep the list current, as you will be referencing it very often to make some very important project decisions later on. Doing an inventory check every six months or so is not a bad idea, too. An excerpt from my list:

    Dia | CutL | Rea | Geo | CRad | Fl | Len | Shnk | Coat | Series              | Qty
   -----+------+-----+-----+------+----+-----+------+------+---------------------+-----
    0.4 |  0.6 |   4 | sqr |    - |  2 |  38 |    3 |    Y | Hanita 7N22         | 4
      3 |   25 | ext | sqr |    - |  4 |  75 |    3 |    Y | Cobra Carbide 24452 | 2
  

  Machining mistakes will often cost you your lunch money. Since it's easy to forget a "lesson learned" for a less commonly used tool, consider writing down application notes. What cutting parameters worked well in what material? Which settings resulted in a broken tool or poor finish?
• Mechanical components: keep a list of all the essential mechanical components discussed later in this chapter. All the screws, pins, washers, springs, bearings, connectors, spacers, rods, tubes, and so forth, are worth enumerating. Plain wire and cable, tape, cable ties, and other commodity materials you can restock locally do not matter that much, though.
  Since most of the geometries for said components are very simple, you might also want to measure them up front. For example, for a non-countersunk machine screw, you would need inner and outer thread diameter, shaft length, head diameter and height. For springs, rods, and tubes, you need outer and inner diameters and nominal length... you get the picture. Don't make any "obvious" assumptions: for example, M2 screws are actually nowhere near this diameter: the thread is usually 1.8 / 1.9 mm.
• Actuators: motors and solenoids from surplus outlets are usually poorly labeled, yet their parameters vary very significantly even for roughly the same form factor. Because of this, you need to do a thorough job of investigating their characteristics. Try to gather as much information as possible before you buy: manufacturer name, model, nominal voltage, and recommended operating voltage range at the very least. If the retailer does not have all the information, scout around: try to decipher and search on the web for any markings seen on photos, inquire with manufacturers if nothing comes up; look for similarly described items in other surplus stores; etc.
  If you can't find the maximum operating voltage, be prepared to sacrifice one motor for destructive testing. To perform the test on a typical brushed, low-power DC motor (this is absolutely not suitable for motors over 10 W or so!), clamp or glue the output shaft to something to prevent any movement, provide a rudimentary heat sink for the motor (might be just a metal vise you are holding it in), place the whole setup on a metal tray away from flammable materials, and start supplying progressively higher voltages to the unit. Start at perhaps 1V, then go to 24V in one volt increments, pausing for about 15 seconds between each step. Check the temperature of the motor periodically; stop if it gets too hot to touch, or if there is any smoke, the smell of burning isolation, or simply a sudden drop in current; then subtract about 25% from the currently dialed in voltage, and use this figure as the maximum value for the motor. If you stopped the test on time and the motor still runs smoothly, you might be able to reuse it for future work.
  The remaining parameters you should know about are no-load and stall currents, no-load RPM, and stall torque for the motor (preferably, at its maximum voltage - although the dependency is roughly linear). If not specified, these can be measured non-destructively: currents with a multimeter; RPM with a makeshift right involving a phototransistor and an oscilloscope, a frequency counter, or - if you feell generous - an electronic tachometer; lastly, stall torque can be measured with a kitchen scale and a 10 cm stick glued or clamped to the output shaft.
  For stepper / brushless motors, wiring diagrams are useful, too. They can be figured out with an ohmmeter to identify coil pairs and tap locations (hints here; some trial-and-error may be then required to figure out coil ordering) - but it would save you some time to have this information up front. For each motor, also try to sketch their general shape, and take measurement of all important dimensions, including any flanges, mounting holes, etc.
• Switches and sensors: look up or measure their dimensions, trigger pressures and displacements, and other applicable operating parameters. For dimensional data, I recommend taking own measurements, rather than relying on datasheets: while some manufacturers are fairly accurate, this isn't always the rule. Trigger pressure is particularly useful, and again easy to find out using a kitchen scale: just gently press it against the scale until you hear a click.
• Other electronics: although this is less important, it makes sense to catalog other passive and active electronic components in your drawers; you will usually not depend on their exact dimensions in a critical manner - but having their names, key properties, package types, and quantities written down helps identify nondescript components, or plan ahead with larger-scale projects. Nothing is more annoying than running out of H-bridge ICs or even just resistors in the middle of a holiday weekend you for once wanted to dedicate to your hobby and your hobby alone.

2.2. Mechanical components

2.2.1. Screws and threaded rods

     Good all-purpose                             A so-so
      screw geometry                          screw geometry
    _                             
   / |________________                     |\________________
   |  ////////////////)                    | ___/////////////>   <-- sharp tip for wood applications
   \_|                                     |/ 
                                               ^
                                            ^  `-- not fully threaded
                                            |
                                            `----- countersink

                                                                        ___  actuated element
           sliding guide                                               |   |  
           ============================================================|   |===================
                                                                       |___|
                                                                         |
                                                                         | rigid linkage
  --------.                                                              |                    _
          |    _________________________________________________________.-.______________    |
  motor   |===[/////////////////////////////////////////////////////////| |//////////////]===| bearing
          |                                                             `-'                  |_
  --------'    threaded rod                                         <-- nut -->

2.2.2. Plain pins, rods, and tubes

2.2.3. Spacers

        Without a spacer                     With a spacer

   part 1              part 2         part 1               part 2
 
   |    |              |    |         |    |               |    |
   |    |              |    |         |    |     spacer    |    |
   |     \_____  _____/     |         |    | _____________ |    |
   |_ _ _ _ _ _||_ _ _ _ _ _|         |_ _ ||_ _ _ _ _ _ _|| _ _|
   :_ _ _ _ _ _::_ _ _ _ _ _: <-      :_ _ ::_ _ _ _ _ _ _:: _ _:  <- screw through hole
   |      _____||_____      |         |    ||_____________||    |
   |     /            \     |         |    |               |    |
   |    |              |    |         |    |               |    |
   |    |              |    |         |    |               |    |

   <----------->                      <---->
    part height                     part height

2.2.4. Springs and spring wire

2.2.5. Ball bearings

2.3. Robot-related electronic components

2.3.1. Motors

• Vanilla: this is the traditional variety of DC motors - with rotating electromagnets and simple, mechanical commutation to switch said electromagnets in a sequence corresponding to motor's current angular position. Such motors have three major advantages: they require no particular external circuitry to run, are widely available in a great variety of shapes and operating parameters (starting with motors measuring less than 4 mm in diameter - see example), and tend to be dirt cheap - with brand name motors starting under $1 or so. Their availability, simplicity, and low price mean you can experiment with lots of unique designs without a significant up front investment.
  Their most significant disadvantage is that they run at very high speeds (commonly between 3,000 and 15,000 RPM when idling, self-limited by back electromotive forces) and deliver relatively low maximum (stall) torques - mandating the use of reduction gears in almost all applications to balance these two parameters in a more useful way. Other problems include the absence of position feedback mechanisms (external sensors are often necessary), electrically noisy operation, and the fact that their power-to-size ratio is limited by the difficulty of efficintly dissipating heat from the rotating armature. Their long-term life is also limited by the wear of carbon brushes - but to be fair, this is seldom an issue for hobbyist work, and more of a problem for continuous duty applications.
• Geared: these motors include an additional integrated gearbox that reduces RPM, and increases torque proportionately (as per the law of conervation of energy). These gearboxes typically operate with a respectable efficiency (85-95%), and offer reductions between 20:1 and 400:1. At the resulting rotational speeds, geared motors can be directly used to actuate a variety of mechanical assemblies in robotic applications.
  The primary disadvantage of these motors is their price, particularly for high-quality planetary gearboxes. Planetary gears are preferred to more traditional arrangements of offset spur gears, because they add very little to the dimensions of the motor, and can be more efficient under load - but unfortunately, you can expect to see prices anywhere between $20 and $150; Maxon motors, favored by researchers, commonly fall in the $100-$150 range. Spur gear motors are much cheaper, commonly between $5-$10, but only some of them are worth buying. Many types of metal gear units (photo) are usually a good investment, because they are very durable, usually reasonably efficient, and, thanks to the use of hardened steel, pretty compact. Plastic (Nylon) gearmotors (example) are usually not worth your time: they are large and flimsy, and it's pretty easy to do better by cutting your own gears to fit a particular application.
• R/C servos: the term refers to brushed DC motors with offset axis reduction gears, additionally coupled with a potentiometer (acting as a position sensor) and a controller circuit (this picture is a good illustration of the internals of a high-end R/C servo). The internal circuit is tasked with receiving positional directives from the outside world - encoded as pulse width or serial binary data on the control wire - and then comparing the requested position with the one sensed by the potentiometer. If the two do not match, the controller attempts to rotate the motor in the right direction to eliminate the difference.
  Servos are extremely popular in hobbyist robotics, simply because they offer a great combination of precision, torque, and hassle-free operation. On the flip side, most of the low-cost ($4-$15) models are bulky (commonly over 5 times the volume of the actual DC motor used!), and their pots and plastic gears tend to be pretty flimsy (replacement gears are usually available, but hey). Lastly and perhaps most annoyingly, many of these servos can't rotate continuously to make a full 360° turn, being limited by the potentiometers used to sense the position - 60° or 180° of freedom is common. A handful of models can be disassembled and tweaked to permit free rotation (usually introducing a gap where the motor loses positional feedback for a while), but this is not a rule. More expensive servos (typically priced over $20) may use proper, 360° two-phase encoders or optical sensors, but it's unheard of in more affordable models - as these feedback mechanisms alone are about 10-20 times more expensive than a simple pot.

• Vanilla: brushless motors deal away with mechanical commutation and rotating electromagnets; in this design, the rotor consists simply of a number of permanent magnets, with no wiring whatsoever. To put it in motion, a set of stationary electromagnets arranged around the rotor is powered in a specific sequence by an external controller. Current or magnetic field sensing is typically used to synchronize this process with the actual position of the rotor and avoid vibration or power losses. The advantage of this design is that it's mechanically simple, robust (no brushes to wear out), much less electrically noisy (no sparking), and most importantly - it does not suffer from the heat dissipation and wiring management issues inherent to brushed designs, allowing much larger currents to be run through the electromagnets without overheating the motor.
  Now, brushless motors have three serious drawbacks: firstly, of all motor types discussed here, they require the most complicated and expensive external control circuitry / software to run efficiently (only a handful of devices, such as computer fans, come with controllers built in). Secondly, almost all the reasonably priced models you would be able to find are meant for high-performance R/C applications - so they run several times faster, and sink several times more current, than their brushed counterparts (10-20 A is common); you can salvage smaller and less power-hungry motors from computer fans or hard disk spindles, but this is obviously not a convenient and sustainable way of doing business. Lastly, brushless motors that are commonly available still tend to be pricey, starting at $7 a piece or so. For these reasons, unless you need a unique power-to-weight factor of these motors, I would say you are better off with other options instead, at least until the landscape changes a bit.
• Stepper: stepper motors are an interesting variation of the brushless motor design: the number of permanent poles on the rotor is significantly increased, and there are more electromagnet coils, designed to have a fairly high "idle" resistance to prevent sinking excess current when the rotor is not spinning. No position, speed, or load sensing is provided as such. Steppers are specifically meant to be operated at low RPM in a sequential, indexed mode: switching the coils in a specific order advances the motor only by a fairly small angle (7.5° or 15° is common in small motors, 1.8° in larger ones), and the motor holds still in between steps. A simple half-stepping algorithm can double the number of steps possible (at the expense of some torque loss), while a more complex control circuit can achieve around 10 microsteps per each step by varying per-coil currents.
  The primary advantage of steppers is that they run efficiently at useful speeds (0 - 300 RPM), deliver a reasonable torque through the entire speed range - typically higher than brushed DC motors of similar size and power requirements - and can be used to execute precise and repeatable movements with no need for extra sensors. Like other brushless motors, they are also very durable. Steppers are commonly used in consumer electronics, such as printers or CD drives, so they are reasonably easy to get through surplus retailers, with quite a few interesting options in the $1-$3 range.
  Their chief disadvantage is that by operating at a low speed, they can't benefit from the back electromotive force equilibrum that limits the current for fast-spinning motors when no load is applied; a regular DC motor might sink 1A when stalled, but only 100 mA when the load is light; steppers, on the other hand, can be considered constant current devices. This property might be undesirable in applications where the average load is expected to be low, but some extra peak torque is required every now and then. A related problem is that because of their high frequency alternating polarity pattern on the rotor, and high inductance coils, stepper motor torque drops off rather aburptly at speeds over about 300 RPM; going past 1500 RPM is difficult and largely pointless in most applications; if you want to use reduction gears to increase torque, there is just not that much RPM head room to use.
  A bit on the types of steppers you might see: most stepper motors have two independently operated electromagnets (or groups of electromagnets). To complete a single step, these electromagnets need to have their polarities changed in a specific four-step order; anything else would just cause the rotor to wobble back and forth. Reversing the polarity of each coil can be achieved with a circuit known as the H-bridge - which comes at a certain additional cost (e.g., $1.00 per motor if you use 2 * FAN8082 ICs). To eliminate this extra complexity, some steppers are designed so that each electromagnet has two complementary, opposite coils that can be operated independently: turn one on to polarize the electromagnet one way, turn the other one on to get reverse the field without the need to physically reverse polarity of the wires (illustration). In such a design, the motor can be driven with a much simpler and cheaper transistor circuit (e.g., for $0.20 per motor if you use 4/7 of ULN2003A); but on the flip side, more room is needed to accommodate these extra coils - so you get less output from a larger, heavier motor.
  The first arrangement, requiring H-bridges, is called a bipolar stepper; the second option, with complimentary coils, is called unipolar. Telling them apart requires some skill: typically, motors with 6 or 8 leads can be driven in either mode, to best suit your needs; motors with 4 leads must be operated as bipolar, as they have no center taps that allow each coil to be split into two; and motors with 5 leads can be tricky: some might turn out to be unipolar-only (split coils with center taps connected together), some might be an oddball hybrid with one coil with a center tap, and one without (this works best with bipolar control).

• Running speed: the faster the motor runs, the more more complex the gearbox would need to be to bring its output to a usable range - commonly somewhere between 15 and 300 RPM. From that perspective, a DC motor running at 3,000 RPM is generally better than a motor running at 15,000 RPM: to bring it's output down to around 50 RPM, the former would typically need 3 reasonably-sized reduction gears, while the latter would need 5.
  On the other hand, keep in mind that very low speeds in some geared motors or servos might be just as unsuitable for certain applications. A 5 RPM geared motor directly driving a wheel would need 6 seconds to complete a single revolution. If the wheel has a diameter of 50 mm, this gives around 0.5 km/h! The same problem applies to steppers with reduction gears.
• Torque: torque is a pretty simple concept: a motor delivering 1,000 g/cm of torque can lift 1 kg attached to a 1 cm lever - or, proportionately, 50 g on a 20 cm lever. In real life, you almost always want to compare motor torque as a function of RPM: for example, if you need the wheels to spin at a particular speed, an appropriate gearbox can be employed to satisfy this goal; but a sufficiently powerful motor needs to be selected for the job first.
  Hmmm... so we know the no load RPM for for a motor, but in this mode, the usable torque is exactly zero; and we know stall torque, but when stalled, the motor is rotating at exactly 0 RPM - also not doing any useful work. How to reconcile these parameters and arrive at something practically meaningful, then?
  The thing is, each motor has a unique efficiency curve; when buying surplus units, you seldom can get this data, but for low-power brushed motors, it usually looks like this. The motor's optimum efficiency is somewhere around 85% of the no load RPM, at which point, the torque is about 25% of the stall value, and current consumption is somewhere around 20%. You can aim for any other point on the curve depending on your needs, but power efficiency will suffer; past 60% of stall torque, it will suffer rather dramatically. High momentary loads are obviously OK (when lifting something, or going uphill), but continuous operation in this region will drain the batteries rather quickly, which is often undesirable.
  In any case, the optimum efficiency is a good reference point: let's try to normalize the torque for a 100 RPM application at optimum efficiency, and use this for any comparisons. The calculation is relatively simple: consider a motor with a stall torque of 80 g/cm, and a no load speed of 12,000 RPM. Good efficiency will be achieved at 10,000 RPM, translating to about 20 g/cm of torque; to bring this down to 100 RPM, a 100:1 gearbox would be used (and not, as no load RPM would imply, a 120:1 one). Factor in transmission losses in the gearbox (10% or so is a good ballpark figure) - and you can expect about 1,800 g/cm of torque at that speed. If this particular gearbox is stalled, you will get 7,200 g/cm peak. What does this means in practice? With 8 cm diameter wheels, this is enough to slowly but surely haul a massive 4 kg robot up a 30° slope.
  Anyway, you can use the resulting formula - torque_100RPM = nominal_torque * 90% * nominal_RPM * 85% / 100 - to compare motor performance across the board.
• Dimensions: size matters - long motors will inevitably prove to be difficult to fit inside an actuated joint - and may end up sticking out and limiting movements in an undesirable way; while wide motors will be difficult to interface to wheels without reducing ground clearance rather significantly. Changing the axis of a rotary motion is not impossible, but not trivial either - bevel gears are a more complicated 3D creature that requires some extra skill to design right, whereas regular spur gears are a quickie in 2D; transferring movement using belts, chains, or racks, is also tricky. So, plan accordingly: short and wide motors for joints, long and slim motors for drivetrains, and above all... the smaller the better.
• Nominal voltage: it's very easy to work with motors rated for 3-9V, and power them from a single supply with all the digital electronics; and it's equally easy to find affordable, rechargeable batteries around this voltage to match your desired application perfectly. With higher voltages, the picture gets more complicated: you will need a separate supply (or pricey DC-DC voltage converters), and may end up having to pay extra for H bridges or transistor arrays capable of driving the motor without leaking out the magic smoke. Higher voltages also greatly increase the risk of catastrophic circuit failures - including the possibility of frying the port or motherboard of your PC - when something goes wrong.
  So, I recommend sticking to the 3-9V range where possible, and advise against using motors over 12V; keep in mind that 12V motors may need a 16V supply or so if you take voltage drops across driver ICs (usually about 1.3V), and battery discharge characteristics, into account. Also, if you plan to venture beyond 24V anywhere in your circuit, you are strictly on your own - you will need to observe safety precautions not covered in this guide. As little as 30-50V can give a pretty mean shock, and may cause fairly spectacular breakdown of some conductive materials and electronic components, even at relatively low currents.
  To be fair, almost any DC motor will run at a voltage as low as 10-20% of its rated maximum. You can definitely run a 24V motor pretty smoothly off of 9V or so; but you will see a roughly proportional drop in torque - meaning you could probably be just as well using a smaller, cheaper motor to begin with.

• Mabuchi FF-N20PN "8117" ($1.20): one of the tiniest but still reasonably powerful DC motors I stumbled upon (pager motors are smaller, but deliver negligible torque). Diameter of 10 / 12 mm, length of 16 mm. Around 15,000 RPM, stall torque is around 15 g/cm (equivalent to ~1,800 g/cm with a 100 RPM gearbox), stall current 1.5A when running on 6V. Good for miniature projects, though power hungry under load. The motor I link to does not match the standard specs available from Mabuchi, so is probably a custom or discontinued model.
• Mabuchi RF-300FA-12350 ($1.50): spindle motor commonly used for CD and DVD drives. A fairly powerful, small motor with an attractive form factor. Diameter of 25 mm, 12.5 mm long. About 7,500 RPM, 30 g/cm (would yield ~1,600 g/cm with a 100 RPM gearbox), 600 mA stall current when running at 6V. A slightly larger but super-cheap Mabuchi FF-500T-10750 ($0.75!) might be an insteresting alternative for some larger projects, too: it is 32 mm wide, 16 mm long, idles at 5,000 RPM, and delivers 100 g/cm (~4,000 g/cm with a gearbox) at 9V, 0.4A stall current. Both these motors are good for walking or wheeled robots.
• Canon EN22 ($1.15) is a nifty, high quality, precision brushed motor running off of 12V. Diameter of 18 / 22 mm, length of 34 mm. Free speed of 9,000 RPM, about 150 g/cm (~8,500 g/cm with a gearbox) at 1.2A. A tempting alternative is a slightly chaper Canon DN26, measuring 25 mm in diameter and 25.5 mm long. That motor idles at 6,000 RPM, and delivers about 80 g/cm (~4,000 g/cm with gearbox) at an impressively low 250 mA stall current (12V). Both are very quiet and excellent for medium size projects.
• Nichibo MD5-2554AS-BB ($1.95) is a very powerful and fast motor for demanding applications. Running at 21,000 RPM with 12V, it delivers around 400 g/cm (theoretically ~65,000 g/cm with a gearbox, though you would need bulky steel gears to handle this) at over 6A stall current. Measures 28 mm in diameter, about 35 mm long. A similar motor with comparable dimensions is Molon CM0-1237 - running at 14V, 13,500 RPM, and delivering around 500 g/cm (~50,000 g/cm with reduction) at 4.5A stall current. Both are good primarily for powering high-speed mecanisms (e.g. propellers, turbines), or for very large projects where high-capacity batteries or mains supply is available. Where weight and motor size is an issue, brushless motors could be an equally power-hungry but much lighter option, too.

• Sanyo 12GN-0348-NA3S and 12GN-0348-NA4S ($7.50): two cheap, extremely small, robust, metal gear motors delivering about 2,200 g/cm (NA3S) and 3,500 g/cm (NA4S) stall torque, and idling around 100 and 70 RPM respectively, when supplied with 6V. Dimensions are pretty amazing: around 12 x 10 x 25 mm. You may want to browse the entire range, too.

• Symbol Technologies 21-02485 ($1.00), about 20 mm wide and 12 mm thick. It is a 5-wire hybrid that is best operated in bipolar mode; it seems to handle 9V well, but gets a bit warm during continuous 12V operation. It rotates 15° per step, consuming about 100 mA per coil. The torque seems to be around 40 g/cm. Not much larger than Mabuchi FF-N20PN, this is quite a unique bargain for driving small loads - but it might require a 10:1 reduction or so to haul anything heavier around the place.
• Epson STP35NI48SV50 ($3.00). About 35 mm wide and 12 mm thick. It's a 5-wire, common bus unipolar stepper, 7.5° per step. Runs off of 12V nominally, consumes about 250 mA per coil, and delivers around 220 g/cm in torque. Can be used to drive appreciable loads with a very modest reduction, and is shorter than most brushed motors you would be able to find. Panasonic 42SPM24DGYE ($2.50) is a larger stepper motor, 42 mm in diameter and 23 mm tall. In my testing, could handle 12V. Moves 7.5° per step, needs around 300 mA per coil. Produces around 600 g/cm of torque!

• Mystery servo EM_43g ($3.50) - a really cheap, miniature 6V servo of acceptable quality, delivering around 500 g/cm of stall torque. Its speed is about 10 RPM with no load.
• Hextronik HXT900 ($3.65) - another affordable, more powerful, slightly larger servo - 1,600 g/cm at stall, 40 RPM under no load, runs off of 6V. Very popular with hobbyists.
• Hxtronik HXT5010 ($6) - a larger, ball bearing servo capable of delivering about 6,500 g/cm st stall. It's slow - 8 RPM with no load at 6V. Reportedly can be modified to rotate 360°.

2.3.2. Linear actuators (or lack thereof)

2.3.3. Sensors

• Tactile switches: one of the simplest, smallest, and chapest sensors available. There are three primary applications you should be aware of: firstly, when placed behind a spring-, elastic pad-, or dowel pin-mounted bumper, they form a great contact sensor, particularly useful for wheeled robots. Secondly, in conjunction with an rubberized foot (in legged robots) or a floating axle (in wheeled robots), they are triggered under robot's own weight, and useful for detecting ground contact. Lastly, they are an important internal feedback device for moving mechanisms, if placed so that the switch is triggered when the assembly is retracted to a particular spot (home position).
  A wide selection of microswitches in all shapes and sizes is available from Mouser, as well as all the other outlets mentioned earlier. Pricing starts at $0.10 or so a piece when bought in reasonable quantities (at least 50 is a good idea). Photos can be deceptive, so be sure to verify dimensions, trigger force, and button travel, then consider how they would fit your potential projects. In most cases, it makes sense to stock up on the smallest, low-profile non-SMD switches with low trigger force you can find (e.g., Mountain Switch MS-100589, 6 x 3.5 x 5 mm, triggers on 160 gf), then some larger but reasonably flat switches with a wide button where a greater pressure-sensitive area is desired (e.g., ALPS SKHCBJA010).
• Optointerrupters, aka optointerruptors, aka photointerruptors: a more expensive class of sensors used primarily for internal sensing, and capable of detecting the movement of a mechanical element traveling through a slot or directly in front of the device. This works by shining an IR LED on the element, then measuring the reflected or transmitted light with a phototransistor. Since measurements are made without disrupting or limiting the movement, optointerrupters in various arrangements can measure speed, relative or absolute angular position, even movement direction, in a very convenient way. All the mentioned stores carry a nice selection of these devices; for example, have a look at tiny, wide-slot Toshiba TLP841 ($0.45), ideal for sensing gear position. Reflective optointerrupters of note include Optek OP609RA ($0.70).
• Mechanical rotary encoders: like optointerrupters, these devices are meant to measure rotation or angular position without limiting the movement - but unlike the previous category, they require mechanical coupling, and hence cause some friction. There are two basic types of such sensors: linear ones, such as ALPS RDC803001A ($1.50), which rely on a heavy-duty rotary potentiometer with several phase-shifted taps to measure absolute angular position of an attached rotating element whilst allowing 360° motion; and pulsed devices such as Mountain Switch MS-101208 ($0.40), which alternate between closed and open circuit when the shaft is rotated, commonly producing 12 or 24 pulses per turn.
  The benefit of potentiometer-based sensors is that they provide absolute positioning with a high resolution - so in many cases, a single device can replace an optointerrupter and a home position switch, reducing complexity and improving accuracy at the same time. Wear and power loss considerations aside, their primary downside is the relatively high price for models that allow 360° measurements, and the need to interface them to an A/D converter to get the reading. Pulse encoders are much easier to use and cheaper, but provide just speed feedback - so a home position sensor is often still required.
• Magnetic field sensors: solid-state Hall effect sensors (such as Honeywell S41, $0.50 a piece), or mechanical Reed switches (no-name example, also $0.50), can work very much like an optointerrupter, and sense the position of a small permanent magnet embedded in the rotating element. Their primary benefit is lower power consumption (no need to drive LEDs), longer lifetime, and the fact they can "see" through plastic covers and work in other scenarios where no direct access to the moving element is possible. Their downside is that they are easy to disrupt when in direct proximity of motors, speakers, high-current or coiled wires, or other sources of magnetic fields. It is also usually more expensive and tricky to embed a tiny magnet somewhere, than it is to drill a small hole or mark a reflective dot.
• Distance sensors: distance sensing is a very important task: it not only allows the robot to avoid constantly bumping into its surroundings, but in more sophisticated designs, can be used to sweep the surroundings to build map out the world in X-Z plane - something far easier to analyze than X-Y images from a camera (even in camera-enabled robots, such depth maps simplify image processing significantly).
  As usual, there are several types of distance sensors: the two most interesting groups are infrared and ultrasound. Infrared is generally cheaper, but has a limited sensing range, and may be considerably less effective in very bright light. One of the most interesting devices in this class is Sharp GP2Y0A02YK, capable of sensing objects in the 20 to 150 cm range and pretty cheap ($10 via Mouser). Comparable alternatives for other sensing ranges (e.g., 10-80 cm) are available to suit your needs; just be wary of "threshold" sensors that simply output one value when the object is farther than X cm, and another when closer than X - not very useful in robotics.
  Ultrasound sensors are far superior - with typical sensing ranges up to 6 meters, and flawless performance even in challenging conditions - but they also cost more. MaxBotix manufactures a range of neat devices such as LV MaxSonar EZ4 ($25 or so). EZ4 detects objects from 15 to 650 cm, outputs serial, analog, and pulse width data, and has a very narrow beam with excellent side rejection, ideal for environmental scanning.
  Other, more exotic types of distance sensors are also available - including laser rangefinders - but tend to cost arm and leg (hundreds or thousands of dollars, that is). In robots equipped with a camera and some spare computing power, the location of a laser dot can be observed directly through the camera, and used to calculate distances, thanks to parallax (example) - but this can be complicated, particularly outdoors, where other bright lights may interfere with the process.
• Digital compasses: in most designs, robots can measure traveled distance very accurately, for example by sensing wheel rotation or measuring distance to a nearby wall. It is far more complicated to keep an accurate idea of the direction the robot is facing, however - as even a very small angular inaccuracies, say 0.5° after every turn, tend to accumulate and create significant deviations in the long run. Digital compasses come very handy for correcting these errors, and also helping the robot understand its location after being lifted off the ground, power cycled, etc.
  I must sound repetitive, but there are (again!) two types of digital compasses to be aware of: ultrasensitive, solid-state Hall effect sensor ICs, such as Honeywell HMC1051 ($20); and regular Hall effect sensors sensing the position of a traditional, miniature compass needle in a liquid - e.g., Dinsmore 1490 (digital output, 8 directions, $15) or 1655 (analog output, $40). Personally, I like Dinsmore units because of their daring design - but it's your call.
• Other fancy sensors: some robot designs may have an use for accelerometers (needed to balance dynamically stable robots, and in designs that are likely to lose contact with the ground often; MMA7361LT is a nice low-cost unit), flex sensors (for measuring deflection, and hence angular position - an interesting alternative to other types of encoders, but two orders of magnitude more expensive), heat sensors (can be used to detect humans and animals pretty reliably; surprisingly cheap, too), inclinometers or tilt switches (for detecting terrain features or dangerous operating conditions), GPS modules (a pricey gadget good for long-distance positioning, but largely unsuitable for accurate positioning indoors), microphones (a pair of microphones can be used to pinpoint source of sounds in a room), or - of course - digital cameras. But unless you have a specific ambitious design in mind, you probably do not need to buy any of this just in case.

2.3.5. Integrated circuit glue and MCUs

Both of the aforementioned Atmel chips come with 32 bidirectional I/O lines, 8-channel 10-bit ADC, and hardware PWM channels, and are available in PDIP-40 packages in case you do not feel like doing too much SMD work. Both accept a wide range of voltages, and are very power efficient, consuming between 0.5 and 5 mA when busy (depending on clock speed). Perhaps more importantly, unlike several other types of microcontrollers (PIC, ATtiny), they have an extensive support for open source C development: a fully-functional port of GCC, GDB, libc, libm, binutils, a nice emulator, and even a decent, dedicated evelopment and debugging IDE. This sure beats manually approximating 32-bit floating point arithmetics in 8-bit RISC assembler.

If chip size is critical, ATmega328P is a narrow PDIP-28 version with comparable specs, but 32 kB Flash, 2 kB SRAM, 1 kB EEPROM, 23 I/O lines, and 6 ADC channels ($4). All these chips are available through Mouser.

For debugging and prototyping more complex algorithms, you might actually prefer to use a regular computer instead. This has some disadvantages - most notably, an external ADC will be necessary to sample analog signals - but also lets you play with arbitrarily crazy algorithms without having to micromanage interrupts and memory layout, or prematurely optimize your code to fit on the chip and run fast enough. The easiest way to interface to a PC is through the IEEE 1284 parallel printer port - programs can set and read back TTL-compatible signals on individual pins directly, at megabit speeds, with no need to negotiate, encode, or time communications in any particular way, unless you want to. This is not the case for any other common I/O port - RS-232 serial ports are slower, use a specific protocol, and require 15V signalling; USB and Firewire connections require a dedicated controller to negotiate with the host and implement packet transmission; and audio inputs and outputs can be easily used for digital communications, but only at fairly low speeds. Industrial and prototyping I/O controllers are another alternative, and more flexible than the parallel port, but also very expensive.

When using MCUs, you will probably benefit from some intelligent way to output status messages and other runtime data; luckily, there is a lot of pretty, neatly backlit text-mode LCDs based on the well-known HD44780 chip - for example, NHD-0216K1Z-NSB-FBW-L ($12). The chip is very easy to interface with using 6 data lines (parallel nibble mode, write-only).

2.3.6. Power sources

Many other ideas for power delivery were floated around and tried in experimental designs, including wireless induction, optical tethers using laser beams automatically following photovoltaic cells, etc; they will not be universally useful, but let your mind wander every now and then :-)

2.3.7. Standard electronic components (duh)

3. Working with the software

3.1. Baby steps with CAD

• RTFM: set aside 2-3 days to actually complete all the tutorials, review manuals, and go through the help pages. You need to understand what the program has to offer, and what terminology it uses. You are not too smart for that, no matter how good you are with computers otherwise. Even if you have some experience with general-purpose 3D modelling software, you will learn a lot. Believe me on this one.
• Check configuration: go through the settings for your program, and make sure your default settings are sensible. Set units to milimeters, editing tolerance / accuracy to 0.001 mm or so (meshing accuracy for display purposes can be much lower), minor grid spacing to 1 mm, major grid spacing to 5 or 10 mm, and grid distance to a value comparable with the work area of your machine. Setting linear snaps to 0.5 mm (or 0.25 mm for smaller projects) is a good idea, so is configuring angular snaps at 15°. For CNC work, I find translucent shading with edge thickness set to 1 pixel to be most useful; but play around. If the program allows you to set a different color for naked (open) edges that are not joined with any other adjacent edges - and therefore, probably result in a non-watertight geometry - then be sure to turn it on.
• Learn keyboard and mouse shortcuts: most CAD programs allow you to type in command names instead of selecting them through a menu, using sort of a mini-shell; learn the names of the commands as you go through the initial exercises, as it's infinitely faster than navigating through multi-level menus or dozens of toolbars. There are also keyboard shortcuts for disabling and enabling grid and object snaps on the go, changing drag modes, zooming or rotating viewports, constraining movements, "nudging" objects by a small distance, etc.
• Never, ever approximate: need to reorient or scale an object? You may be tempted to just zoom real close, and drag-and-drop until the effect is visually acceptable - but in CAD applications, this will come back to haunt you. Approximations like this will introduce hard-to-diagnose geometry problems: curves that imperceptably self-intersect and therefore can't be turned into 3D surfaces correctly; open shapes that almost, but not quite form a solid; or other kinks and seams that look OK until something, later on, goes horribly wrong. Small variations in surface heights also make waterline machining hard to set up. Both CAD and CAM applications do a poor job of explaining why, exactly, you are not getting the expected result; if things go wrong, you might need to deconstruct the shape and spend a lot of time checking every single knot / control point - or start from scratch. So, don't cut corners: all CAD programs have extensive numeric data entry capabilities, linear, radial, and object snaps, "orient on curve" and "orient on surface" operators, and so forth; all these allow you to maintain accuracy - and you really have to learn them to survive.
• Avoid 3D operations that claim to do all the thinking for you: most CAD programs provide product-selling features to effortlessly tweak complex shapes: for example, you have tools to calculate intersections or unions of closed geometries, place or move holes, etc; but all this leads to cummulative dimensional inaccuracies, and sometimes, unexplained geometry glitches. A much safer approach is to break down complex problems into simple steps, and operate on intuitive primitives (planar curves and surfaces) for as long as possible in the editing process. Bundled tutorials will likely show you the right way to do it.

3.1.1. Drawing and manipulating basic curves

• A single line segment,
• A multi-segment line (with simple, sharp corners; also see how to close it to form a continuous shape),
• A circle - center point + diameter, between two points, between three points, arc, etc,
• A rectangle - by specifying corners, or a center point,
• A polygon - circumscribed and inscribed, with a specified number of sides.

• Move (proper command, not drag-and-drop in the UI),
• Rotate,
• Flip / mirror around a specified axis,
• Scale proportionately (in all 3 dimensions),
• Scale non-proportionately (in a single dimension),
• Clone / make copy,
• Make linear array,
• Make radial (polar) array.

• Measure distance,
• Measure angle,
• Measure diameter / radius,
• Find center,
• Measure surface area / volume.

3.1.2. The inner workings of splines

• Displaying control ("attraction") points, moving, inserting and deleting them,
• Displaying and changing control point weight, if supported,
• Displaying edit ("via") points, moving, inserting, and deleting likewise,
• Adding a kink,
• Changing the degree of a curve segment,
• Displaying curvature and continuity information for a curve.

• "Explode" operator to split a curve at kinks (but not regular knots) - see what it does to a rectangle, to a circle, etc,
• Join operator that merges adjacent curve endpoints to form a single logical curve with kinks,
• Commands that let you draw curves with degrees higher than 1 by specifying control or edit points.

3.1.3. Curve reassembly

3.1.4. Other useful curve tools

  |                |                |                : |
  |                |                |                : |
  |                `                 \               : |
  |                \                  \              : `-----
  |_______          `-._____           \____         `.......

    input           fillet           chamfer          offset

3.1.5. Creating simple surfaces

3.1.6. Managing the mess

3.1.7. Practice time (and some rules to go by)

   _________________________
  |.-----------------------.|
  ||                       ||
  ||      ,-~-, ,-~-,      ||
  ||     /     ,     \     ||
  ||    |             |    ||
  ||    |             |    ||
  ||    `.           .'    ||
  ||      `.       .'      ||
  ||        `.   .'        ||
  ||          `.'          ||
  ||                       ||
  ||_______________________||
  `-------------------------'

• The first step of the milling process aims to remove bulk of the material efficiently - but perhaps not very accurately (high chip loads and rapid cutting speeds increase material deflection, tool or material chatter, and so forth); subsequent steps trace over the surfaces to remove the remaining material more neatly, and take care of other fine detail that needs different cutter movements to recreate.
  The initial process - called roughing - is best done with a relatively large tool: perhaps 3 mm for relatively small and intricate molds; and 6 mm for larger, deeper, or geometrically simpler ones. Larger tools remove more material in a single pass simply because of their greater area of contact. They also are more robust (proportional to the square of the diameter) and therefore, can be driven deeper, or operated with higher speeds. Consequently, a 1 mm cutter is not merely three times less efficient than a 3 mm one; 25-50 times is a more accurate figure.
  This brings up the first important rule: design the part, and the mold, so that it can be brought as close to the final shape as possible, with the largest tool you plan to use; the fewer regions you need to touch up with other tools, the less time the whole cutting process is going to take. Notice how in our model, I asked you to leave 4 mm on the sides of the heart: this is enough for a 3 mm tool to pass there cleanly, with some safety margin for the roughing process (more about it later). Were we to leave 2.5 mm instead, we would have to re-machine large portions of the mold later on.
• The remaining steps of the cutting process will generally use progressively smaller tools; the smallest tool you will need to use must have a diameter matching the smallest hole, slot, or corner fillet you wish to have on your model (but protruding pins, walls, or any other elements that are profiled from the outside do not count here). Since most CAM programs fail in unexpected ways when tool diameter is exactly equal to hole diameter, it's actually best to avoid this situation, and always use a tool at least a bit smaller than the clearance it needs to navigate. In our particular case, only two areas can't be properly cut with the first 3 mm tool: one is the center top kink in the heart, and the other are the inner corners of the mold cavity. For the former, you can go back to your CAD application and use the fillet operator with a radius of about 1.5 mm to check if the result of machining the mold with a 3 mm tool will be aesthetically acceptable; if not, you will need to re-machine it with a 1 mm cutter (which leaves a nearly imperceptible fillet here). The latter artifact - the corners of the mold - has no impact on the result, and can be left as-is.
• The reach of every tool you plan to use will need to be equal or higher than the maximum height of any vertical surfaces to be profiled by that tool; you can't make a straight, 20 mm deep hole with a tool that only extends 10 mm. In our case, the reach of the 3 mm tool needs to be at least 8 mm (walls of the mold cavity); the 1 mm cutter, if used, needs a reach of at least 6 mm (height of the heart), and if shorter than 8 mm, should be kept away from the edges of the mold.
  Note that sloped walls can be machined deeper than the maximum reach of the tool, but you need to carefully account for the shape of the tool, collet, and spindle assembly to avoid trouble.
  It's also worth noting that you should avoid using excessively long reach tools when not necessary. The longer the tool, the more susceptible it will be to runout or chatter; and the more vulnerable it will be to breakage - the protruding part of the cutter acts as a lever, and longer reach translates to higher mechanical advantage. For working in prototyping boards, breakage is only a peripheral concern for 3 mm and larger tools; but rapidly becomes an issue below this limit. A 1 mm cutter with a 30 mm reach is extremely difficult to operate; a 10 mm version will take a lot more abuse, but can still snap easily if plunged into material by accident.
• The geometry must be designed so that the cutting process can be organized efficiently. For example, if you only need a part of the model to be re-machined with a smaller tool, and your program only offers limited region selection methods (e.g., rectangular selections in Mayka), make sure the mold is arranged so that you can do it without having to hit random nearby features, as doing so will slow you down at best, or cause trouble if tool reach is shorter than the height of these details.
  Pay attention to other geometry parameters, too: say, one of the most efficient and accurate methods of finishing flat parts with complex outlines in the X-Y plane (our heart is a good example) is waterline cutting. Alas, most CAM programs only let you set this process up only at constant Z intervals - say, 1 mm - so if the X-Y outline changes suddenly at a Z height not divisible by this value, some of it will not be machined correctly:

    ___.        _                    __.          _
    XXX|                             XX|
    XXX|                             XX`-.
    XXX|__.     _                    XXXX'--.     _
    XXXXXX|                          XXXXXXX|
    XXXXXX|                          XXXXXXX|
    XXXXXX|     _                    XXXXXXX|     _
    XXXXXX|                          XXXXXXX|__.
    XXXXXX|                          XXXXXXXXXX|
    XXXXXX|__   _                    XXXXXXXXXX|  _
  
    easy waterline                difficult waterline
       cutting                          cutting
  

  Cleanup passes can be manually added, but this is painful and time-consuming; the program may also be requested to automatically detect flat areas and insert waterline steps there, but as a rule, this applies globally, and not only to the region where it actually makes sense - so the result may be very suboptimal.
  In our particular test mold, all features of the geometry are aligned to 2 mm in the Z axis; sensible Z steps usually range from 0.5 to 2 mm for larger tools, and 0.25 to 0.5 mm for tools 1 mm and below, so you should be in the clear.

• Overly thin bottom surface of the mold: at least 3 mm is advisable for 40 Shore A silicones to ensure sufficient strength and dimensional accuracy; closer to 5 mm for large volume parts.
• Long, tall outer walls with unreinforced sides: if the outer wall holding the resin in is thin, tall, and long, and holds back more than few mililiters of resin, it will likely deform under load. Mold depths greater than 10-15 mm warrant making the walls slightly thicker in critical sections (they can also be reinforced later on by gluing a strip of PMMA or other rigid plastic on the outside, but it's messy).
• Very narrow and long molds: if you make a mold 5 cm wide and 20 cm long out of flexible silicone, you will have a significant difficulty laying it perfectly straight, because the force needed to elastically deform this shape is negligible, and easily overcome by surface friction; adding wider sections in the center helps (and so does using a ruler if you mess this up).
• Long, thin protrusions reaching back to the surface of the mold: deep, small diameter holes in the rigid positive mold should be machined to end 0.1 to 0.2 mm before the intended bottom of the master (top of the negative mold); otherwise, the resulting silicone protrusion will end up touching the plastic cover - and if the cover is moved even very slightly, it will deflect to follow. Leaving some clearance fixes this problem. While this 0.1-0.2 mm extra will leave a thin film at the top of every hole, this film is very easy to remove without leaving a trace.
• Very deep positive masters: pulling out a silicone casting from your CNC master may be difficult if mold depth is higher than 10-15 mm, and all outer walls have 90° and go straight to the bottom; making the outer walls gently sloped (1-4° or so), staircased, or simply adding a 6-8 mm thick pull tab somewhere, makes things much easier. Adding a draft angle and pull tabs is an absolute necessity for mold resins around and over 80 Shore A.

3.2. Creating toolpaths in CAM software

3.2.1. Importing and orienting the geometry

3.2.2. Roughing toolpath

Toolpath distance has a similar effect, but in another plane. The value simply needs to be lower than the diameter of the tool, otherwise the toolpath may not make any sense (and your CAM program may opt not to warn you about this subtle detail); 1-2 mm should work well in our case.

Next, margin size should be set so that the cutter can still machine most of the narrow spots on the mold - not necessarily all of them, but as discussed earlier, bulk of the work should be done in the roughing pass. Be careful: if a slot on the mold is 4 mm wide, the cutter is 3 mm, and margin is 0.6 mm, the region will be left uncut (3 + 0.6 * 2 > 4). It is tempting to set margin to 0, but heavy cutting tends to leave tool marks - so in most cases, leaving around 0.3 - 0.5 mm makes more sense; 0.3 mm is my recommendation for our sample mold. Here's a nice trick, too: if the program does not have a specific setting to define a margin, simply edit the tool to add 2 * margin to its declared diameter; and offset the toolpath by margin up in the Z axis (or even move Z origin up manually on the machine). The effect will be exactly the same; just be careful not to accidentally propagate these values to other processes that are not meant to have a margin.

• The center of the tool needs to stay within the selected region (so, a region extending one radius length outside the boundary will also be profiled),
• The entire tool stays within the boundary (keeping the center of the tool at least one radius away from the boundary curve),
• The tool may go outside as long as it touches the boundary - up to a full diameter of the tool.

3.2.3. Finishing toolpath

• The expected margin left on purpose on all surfaces for finishing,
• Some extra material up to Z step height on the horizontal and sloped surfaces whenever the waterline step is not aligned with the geometry of the part,
• Completely uncut holes / slots where the current tool should fit, but tool + stock did not.

If a particularly fine finish is required, especially with larger tools, lowering feed speeds to 30%, using unidirectional, linear toolpaths, and perhaps reducing RPM a bit (to 80% or so), is often a good idea.

Another random tip: when making deep cuts with limited chip removal opportunities using small, long-reach cutters (say, 1 mm diameter tool cutting an 8 mm hole 1.5 mm in diameter), finely powdered chips may end up getting compressed by the neck of the cutter, and effectively reduce hole diameter by deflecting the tool. A good way to minimize this problem is to machine the hole twice.

3.3.4. Final sanity checks and exporting toolpaths

• Do the toolpaths look OK? Are all the regions machined as expected, on all Z levels? Is the sequence of operations correct? Are there any toolpaths in regions where you would not expect them to be - e.g., outside the mold? Do the toolpaths enter all the tight spaces as expected, or do you need to adjust sampling accuracy? Run a simulation if supported by your program, or examine the paths manually, layer after layer, if not.
  Even if your design is perfect, CAM programs have annoying and inexplicable bugs: for example, I had one of the programs tested ignore a large and well-defined part of the geometry for a specific part sampling tolerance setting, and just plow the cutter through it during finishing; tweaking this value 0.001 mm in any direction would make the glitch go away.
• Is the tool moving above the workpiece? In applications that require you to specify rapid movement height manually, confirm that it is actually set to be above the entire machined geometry; Mayka and DeskProto seemed particularly tricky in this regard, while VisualMILL is nice enough to support auto-detection of a safe movement distance.
• Are the toolpaths reasonably efficient? Is there a lot of back-and-forth movement between regions, unnecessary tool retractions, etc? If yes, try to split the cutting process into smaller steps, adjust sampling accuracy, turn off special entry and exit strategies, turn on optimizations and sorting, etc. Erratic operations here may easily double the machining time - no joke.
• Is all the numerical data entered correctly? Re-check the maximum depth of generated toolpaths versus tool reach. Are all the feed speeds and tool diameters as expected? It's quite easy to enter 600 RPM instead of 6,000, or use a margin-adjusted tool for finishing.
• Do you have everything covered? Are all the regions that need special machining accounted for by the right combination of extra finishing steps? It's easy to overlook a single hole to drill, and it's really annoying to discover this two days later, when you are ready to assemble your prototype.

4. Making parts

4.1. Milling

Finally, hook up the mill to the computer, mount the right mill in the collet, and turn the power on. Set the coordinate system to G54 if applicable, then use the bundled software or a hardware control panel to set the X and Y origins about 2 mm from the bottom leftmost corner of the stock (i.e., slightly over the workpiece); and Z origin at the top of the part. You can use a Z0 sensor, or - if the machine does not have one - simply grab a thin strip of paper and hold it under the cutter to spot the right moment while carefully lowering the spindle using the control panel (no refunds on your fingers, so affixing it with some tape may be a good idea instead).

Every time you want to output any data to the machine, there's one more important thing you always need to check: that the tool is above the workpiece in the Z axis. If it is not, perhaps because you aborted a previous cutting attempt or tried to check something outside the milling envelope, sending a new toolpath will likely cause the cutter to plow through the part on its shortest way to the next destination. Some CAM programs know to avoid this, or can be instructed to do so by manually entering some G-code to retract the tool first - but it's not a rule, so don't bet any money on this.

Anyway - let's start cutting! Some mills allow you to adjust cutting speed dynamically, using a hardware jog dial or some sort of a software slider; if so, make a habit of dialing it down to the minimum setting before starting a process, and ramping up the speed to 100% once you see the cutting takes place in the expected spot and in a sane manner. In any case, hold your hand on the "abort" button, grab some eye protection, stand clear of the table, and... hit "send"!

With any luck, several minutes later, you should have the mold ready; if a tool change is necessary halfway through the process, be sure to vacuum off the chips and redo Z0 sensing for the new tool. Forgetting that last step can be an expensive mistake.

There are several things that can go wrong, but should be pretty self-explanatory: if the machine starts cutting at an unexpected location, or too high / too low in relation to the workpiece, you probably messed up CAM model alignment or setting X, Y, and Z origins on the machine. If your tool breaks while cutting at the expected location, you probably used incorrect RPM, feed speed, or cutting depth parameters. If the workpiece comes loose (which, by the way, you do not want to happen - really, with industrial machines milling metals, people have died this way), you need to do a better job attaching it. If the machine stops suddenly, you probably overloaded it, or it couldn't communicate with your PC - perhaps because of incorrect port settings, or the power save mode kicking in. Incorrect dimensions of the machined part are usually due to installing the wrong cutter. If you run into any problem you can't figure out, feel free to drop me a mail, and I'll do my best to help.

You are probably anxious, but before turning off the mill and removing the part, vacuum off some of the chips again and carefully examine the result, with a flashlight if necessary: were all the areas machined exactly as expected? Anything that needs to be retouched? When you turn off the machine and remove tha part, there's no going back - the alignment of the workpiece is lost, and will be very difficult to accurately restore.

4.2. Casting negative molds

Well, that's it! Cover the mold with a piece of plastic (preferably also treated with mold release), put something flat and heavy on top of it, then stop the whole thing from sliding off by resting something by the edges of the cover. Covering the mold to avoid air entrapment is a bit of an art form by itself, but after several hits and misses, you will get it right: the trick to be gentle, slow, and to start at one of the edges instead of just dropping it centrally. You also need to make sure that the cover is not electrostatically charged after wiping it and applying the mold release earlier on - touch it to the tin foil flange around the mold, or somesuch.

With silicones, about the only problem you can run into is just poor cure, with the surface of the mold being tacky, or - worst case - the entire mold being soft and gummy. These problems can be caused by insufficient mixing (especially if it occurs in strips or patches), incorrect mixing ratios (polyaddition silicones are very sensitive to this - measure carefully), or cure inhibition due to contact with incompatible chemicals (especially liquid dyes, certain types of rubber, and foodstuffs). If this happens, to rescue the master, first put it at 50-60° C for a while, to see if the remaining resin is inclined to cure. If not, wipe as much of it as possible, then use naphtha to dissolve the rest.

Another less likely problem is that some liquid additives may also cause premature cure of the material, rendering it thixotropic and impossible to pour into a mold; but this will be obvious early on. All in all, the number of problems you are likely to run into is limited... and if things go south, again, don't hesitate to ping me.

4.3. Making polyurethane castings

The likelihood of trouble when casting polyurethanes is quite a bit higher than when dealing with silicones, and chances are, your first casting will not be perfectly right; don't get discouraged - because of the shorter working time and greater sensitivity to contaminants, the process takes some skill to carry out flawlessly; and even as you get familiar with all this, you should probably expect a 5% rejection rate for molded parts. Air bubbles are one of the most significant issues. While an occassional small bubble of air does not necessarily ruin a large part, an unfortunately positioned one may critically weaken a tiny gearwheel, or be an aesthetic blemish in a transparent component.

• Voids at the bottom of holes and in slot corners: similar to what can be seen in silicones, this is caused by air entrapment when pouring the resin. Can be avoided with a more careful pour, by using a syringe or a stick to apply the resin to problem areas, or by in-mold degassing under vacuum.
• Medium-size bubbles near the top of the mold: single bubbles around 1-3 mm in diameter are usually attributable to air entrapment. In covered, single-part molds, such bubbles may also get trapped when the cover is put on without due care, or over too little resin. In closed multi-part molds, another reason for large bubbles is that there were no appropriate vent channels to allow the air to escape and be displaced with the resin.
• Large tear-shaped bubbles: in covered single-part molds, these usually appear near edges of the mold when excess pressure is initially applied to the cover (forcing too much resin out), and then removed, allowing air to be sucked back in. In multi-part molds, when appearing around mold parting lines, they usually indicate resin leaks. If seen in large numbers and rising from the bottom of the mold, they may also indicate a very significant chemical incompatibility with a pigment or other additive, or excessive curing temperature. Several extremely sensitive transparent resins may respond with giant, oddly-shaped bubbles to residual moisture or very low curing temperatures that permitted trace moisture to be absorbed from the surrounding materials before cure - but most compositions don't.
• Small bubbles all through the resin (foam-like): in low viscosity polyurethanes, such sub-milimeter bubbles are typically a sign of pigment contamination (moisture), poor mixing, or incorrect mixing proportions. In very high viscosity resins (thixotropic, etc), this may be indicative of insufficient degassing, but this is uncommon.
• Clusters of tiny bubbles (frothing) on the top surface: poor degassing, resin exposed to air (and your breath in particular) for too long before the mold was covered. Disturbing the resin while it's still curing and tacky may also nucleate bubble formation in places where it would normally not occur; foam clusters appearing near mold edges, for example, are typically caused by accidentally bumping and moving the cover a bit during the first minutes of cure. Sometimes, low room temperature during the cure may also contribute to this problem, allowing the resin to stay liquid for too long; 20-25° C is preferred, so a space heater is often an unexpected solution to this problem.

5. Assorted mechanical engineering notes

5.1. More complex mold types

• Two-part molds: simple shapes that are concave on their back side are relatively easy - consider this geometry:

  
           .----.
         .'      `.
        |   .--.   |
     ___' .'    `. `___
    |     |      |     |
    |_____|      |_____|
  
  

  The process of making a two-part mold would simply involve first placing the part on a pedestal several milimeters thick, and slightly wider than the part, and milling it the usual way; then, reversing the whole thing, removing the bottom of the pedestal, and cutting the bottom:

  
    _                              _         _                              _
    X|                            |X         X|__                        __|X
    X|           .----.           |X         XXXX|_______        _______|XXXX
    X|         .'      `.         |X         XXXXXX      |      |      XXXXXX
    X|        |   ....   |        |X         XXXXXX      |      |      XXXXXX
    X|     ___' .XXXXXX. `___     |X         XXXXXXXXXX  `.    .'  XXXXXXXXXX
    X|    |     :XXXXXX:     |    |X         XXXXXXXXXX.   `--'   .XXXXXXXXXX
    X|   _|_____:XXXXXX:_____|_   |X         XXXXXXXXXXX.       .XXXXXXXXXXXX
    X|__|XXXXXXXXXXXXXXXXXXXXXX|__|X         XXXXXXXXXXXXX`   'XXXXXXXXXXXXXX
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX         XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  
           Master for side 1                        Master for side 2
  
  

  Observe that pouring silicone into the first master will yield a concave, negative mold with a flange; while the second one will result in a top cover with a protruding convex shape, and a flange that mates with its counterpart. Since the halves need to mate precisely, it is important to account for compatible corner filleting in the model - but otherwise, the process is very straightforward. For large parts, the pedestal must be reasonably thick or reinforced with rigid plastic, to prevent it from deflecting under its own weight, and that's it. For integrity reasons, many types of multi-part molds benefit from 60-70 Shore A rubbers.
  In some of the more complex molds, thin pathways (1 mm thick or so) must be added to allow the air to escape from certain spots, or resin to be injected with a needle; this will leave a mark, but it should be very easy to cut it off and file it down (in fact, you can see similar marks on the inside or bottom of almost all injection molded plastic parts in existence). A reservoir for some extra resin may be introduced on top of one or more of these channels, especially in pressure casting - so that air is not immediately sucked in as the resin gradually fills the voids.
  In some cases - for example, spherical shapes - it may make more sense to have the partition line in the middle of the geometry, and not at the very bottom; the approach is the same, and the only complication is that the partition line needs to be sealed (for example with silicone grease), and the resin must be injected with a needle through a channel on top of the mold.
• Large molds: the primary concern with large parts is the cost of the silicone, and the fact that the mold may be pretty heavy - sometimes requiring additional sections and hacky reinforcements to prevent it from deflecting under own weight. To solve these problems, an initial thin coat of silicone can be poured or brushed over an oversized geometry in several steps to form a skin layer, perhaps 1 mm thick, instead of submerging the master fully; further build-up usually involves another batch of silicone with a thixotropic additive to make the mold thicker, usually up to about 5 mm or so (and sometimes reinforced with gauze or other light fabric). Finally, a rigid polyurethane shell is then brushed on top of these layers, to form a hard backing with a flexible, removable rubber insert inside (example). A specialized, thixotropic polyurethane resin for building such inserts is Innovative Polymers IE-3065.
• Rigid molds: when casting soft materials, or when dimensional accuracy is of utmost importance in two-part molds, it makes sense to resort to rigid or semi-rigid molds that can be clamped together or placed on uneven surface without affecting the part. Simple molds for tires and other silicone goods are best to machine directly in the prototyping board; polyurethane rubbers around 70-90 Shore A (e.g., IPI IE-9080) can also be used. As noted, a truly religious application of mold releases is necessary, and incorporation of draft angles to facilitate part removal is important, too.
• Molds for non-CNC items: there are quite a few good mold-making tutorials available from resin manufacturers, so I will not repeat this information here. In general, the task involves building a suitable box, attaching the master model inside - typically at the bottom - and then, if necessary, cutting the rubber carefully to recover the original item and allow the plastic to be poured in. These techniques may come handy with parts that are easier to machine directly (e.g., on a rotary axis), or for replacing damaged third-party objects without the need to create CAD models and machine them yourself. Exactly the same resins, mold releases, etc, can be used.

5.2. Part geometry tips

• Baseline part thickness: 1.5 mm for is a good starting point for enclosures, bases, and so forth; between 1 mm is good for gearwheels up to about 1,500 g*cm of torque, with progressively thicker gears or higher pressure angles being necessary past that point. When dealing with large, load-bearing parts, keep in mind that a sheet of even the hardest plastic can be fairly flexible if thin and long enough. Do not work around this property by simply increasing part thickness until it's stiff enough - it's costly, and makes shrinkage and exotherm issues more pronounced. Use strategically placed walls, ribs, flanges, or even flat surface features to reinforce the geometry, instead (click here for an example of a reinforced gearbox cover). The science of bending is pretty complex, but you can probably already appreciate the difference between a flat sheet of metal and an I-beam or an angle; the same applies to polymers. This is how lightweight and seemingly flimsy plastic furniture is made to support your weight, and cheap toys are made to survive being stepped on.
• Fitting tolerances: for most interference fits in plastics, you simply want to make the two mating parts of exactly the same size, sampled with a resolution of at least 0.001 mm (be sure to account for filleting!). Where friction needs to be reduced, a clearance between 0.002 mm to 0.01 on every side usually works fine. In both cases, when such tight fits are necessary, special care must be taken to minimize mold and part shrinkage: allow a full day for the resin to reach handling strength, and then attempt a gradual post-cure only after demolding.
  Also keep in mind that thin, wide parts mounted on an axis are particularly prone to play: if you have a gear wheel that happens to be 2 mm thick and is 40 mm wide, and mounted on an axis with 0.02 mm clearance on each side, the outer edge will be able to wobble by almost 0.5 mm up and down - and that's before taking elastic deformation into account. There are four ways to prevent it: adding a neck to increase the contact area with the axis; making the fit tighter; reducing part width; or preventing movement in undesirable directions with sliding guides.
• Screw holes: measure the inner diameter of screw thread with a caliper, then subtract about 0.03 mm, to get a value to use as a self-tapping hole diameter that would not require a nut. This only works in rigid elastomers that are not prone to stress cracking, though: acrylic and polyester may not take this kindly. In softer plastics, you may need to offset the diameter further, too.
• Minimum wall thickness: depends on the material you are working in and the cutter used, but it is safe to say that tall protrusions 0.75 mm and under, as well as any walls 0.25 mm thick or smaller, require special attention and very careful mold handling in RenShape 460. If created unintentionally and machined at normal speeds, they will likely break off and leave an ugly mark - so avoid them where possible: always chamfer any non-essential acute angles and inspect the mold for similar problems.

5.3. Desiging spur gears

Begin by deciding how many teeth your gear needs to have, and how thick each tooth needs to be. For the gear construction method outlined here, you can go for almost any tooth count - at least 10 is recommended for optimal strength, but lower values are definitely possible. Tooth thickness is mostly limited by the cutting tool available (as the tool will needs to cut matching slots for meshing gears). For example, for a 0.4 mm cutter, you probably want to keep tooth size in the 0.5 - 0.7 mm range; it must be somewhat higher than the diameter of the tool.

Every normal spur gear is described in terms of a pitch circle - a nominal circle at which two meshing gears should be touching, and at which the thickness of every tooth and the corresponding slot is exactly the same (illustration). For any given tooth count and tooth size, you can arrive at the diameter of this circle by calculating tooth_count * tooth_size * 2 / π. The metric system is further based on the concept of a "module" - defined as pitch_diameter / tooth_count (and therefore equal to tooth_size * 2 / π) - as a different, less intuitive, but much easier to measure way to describe any given gear.

As hinted, meshing gears should be generally designed so that their pitch circles touch with each other. Once you have calculated and drawn the pitch circle itself, the next step is to pick a yet another defining property for your gear, called the "pressure angle"; this is the angle at which the torque is to be transferred between mating gears, shown as a solid red line in the animation above. Gears designed for higher pressure angles will have thicker, more robust teeth - but will also also generate stronger axial forces, will be more noisy, and if given the opportunity, more prone to slippage. High pressure angles increase the curvature of tooth profile, making it more pointy for low tooth counts, and requiring a smaller cutter under the pitch circle in high tooth count gears. My recommendation would be to stick to 12-18° at torques up to 2,000 g*cm or so; and use 20-25° past that point. The standardized values used in most of the commercially available gears are 14.5°, 20°, and 25° - but there is nothing special about these numbers as such.

Now, moving on! Let's draw a line tangent to the pitch circle, and then rotate it by the value of the selected pressure angle, in relation to the point where it touches the wheel; then, draw a second circle with the same center as the pitch circle, but tangent to the rotated line (this is marked with a dashed red line in the animation). This new circle is known as the "base circle"; if you do not want to bother with constructive geometry, the diameter of the base circle is simply pitch_diameter * cos (pressure_angle). The significance of it is that no power transfer is supposed to occur below this circle; and that tooth profile above the base circle is an involute curve originating from its surface. Involute is an interesting curve best visualized by imagining having wrapped a piece of string around the circle, attaching a pencil at the end, and then moving the pencil away from the circle. As it moves, and is pulled by the string, it draws a curve like this.

The parametrization of this curve is x = r * cos(t) + r * t * sin(t), y = r * sin(t) - r * t * cos(t), but in most CAD programs, it is actually easier to approximate it using a simple iterative algorithm. Assuming that the pitch circle is at (0,0), it goes thus:

1. Let offset = 0,
2. Draw a point at x = offset, y = r,
3. Rotate point around (0,0) by 360 / (base_diameter * π) * offset degrees to the left,
4. Increase offset by base_diameter * 0.01 (the constant defines curve approximation accuracy, and can be changed),
5. Go to 3 until the desired length of a curve is created.
6. Select all created points, fit a curve through them with the desired accuracy.

With the involute constructed, it is now time to decide what the tooth height should be. To ensure good meshing and tooth strength, most sources recommend making it equal to roughly the module (or, 2 * tooth_size / π); making the tooth shorter - down to 50% of the module or so - is sometimes beneficial, however, as it may help you avoid pointed tooth profile in very small gears, or insufficient cutter clearances in large ones; there is no significant harm in generating stub gears with only 70-80% the nominal height if necessary.

Once you settle for a particular height, draw an addendum circle with a diameter of pitch_diameter + tooth_height * 1.98, and a dedendum circle with a diameter of pitch_diameter - tooth_height * 2.02 or so. The addendum circle marks the height limit for every gear; the dedendum one tells you how far every slot between teeth needs to extend to accommodate a meshing tooth; the clearance created by the dedendum needs to be slightly larger than the addendum in standard gears, but the adjustment values mentioned here are arbitrary.

When you have all these circles and an involute curve drawn, calculate the angle corresponding to a distance of 1/2 tooth width along the pitch circle: 360 / (pitch_diameter * π) * tooth_size / 2. Next, draw a vertical line extending from the center of the circle to the outside, and rotate it by this angle. Rotate the involute curve so that it passes through the intersection of this line and the pitch circle - and mirror it in the Y axis. You should have much of the tooth profile on the screen. The remaining part down to the dedendum line can be drawn by extending a straight line to the center of the circle. You can then use the trim operator to trim the parts extending under the dedendum, over the addendum, and trim the addendum circle itself, to form a complete tooth profile; and join all the resulting segments if necessary. Voila?

Well, almost - this is where most of the guides you can find on the Internet end, but it's not exactly that simple! This approach only works if the total number of teeth is higher than 2 * tooth_height_factor / sin(pressure_angle)²; for full length gears (factor 1.0), this is 30 teeth at 15°, 17 at 20°, and 12 at 25°; for stub length gears with a factor of 0.7, the limits are 21, 12, and 8, accordingly. If you have fewer teeth, the tips of each tooth begin to interfere with the profile of the slot as they move in or out - especially when a significant difference in tooth count, and therefore the curvature of each gear, exists; this drawing illustrates the problem pretty well. An extreme case of differences in tooth count is meshing with a rack - which can be considered a gear with an infinite diameter with a base circle under the dedendum circle, and a perfectly straight involute with an angle matching the pressure angle (see example). This image shows various stage of a rack tooth entering and exiting a gear, as would appear to a camera mounted on the gear itself, and fixed on a particular tooth; the concave area at the bottom is the undercut not accounted for by the involute curve, but necessary to properly mesh in this situation.

So, what do we do? Generating the undercut curve is actually fairly simple - the algorithm amounts to drawing a single, centered rack tooth engaged with the gear, then making copies of this tooth at linear offsets and rotating them by an angle corresponding to a matching distance on the pitch circle: a method very similar to how the involute itself is approximated.

All right, all this probably sounds ridiculously confusing - and rightly so. While completing this exercise manually a couple of times is a very valuable lesson, I have a simple shell script that implements almost all of the calculations and construction steps for you in Rhino, so that you do not have to spend an hour on every single gear: click here to download it (to run the script, you need to have Cygwin installed). The script takes tooth count, pressure angle, module, and addendum as parameters in the command line, and generates a sequence of commands that should be pasted or loaded into the application. The following steps still need to be carried out manually later on:

1. Rotating the involute curve - the one pointing right - around (0,0,0) from where it intersects the pitch circle (marked in red) to the intersection of the right tooth width guide (black line). Be sure to use "int" object snaps for this.
2. Mirroring the involute curve and the undercut curve (pointing left) around in the Z axis, drawing a circle with a diameter of tool_diameter + 0.05 mm, and dragging that circle around to sure that the tool will be able to enter the slot; minor adjustments to the undercut curve are OK, but if there is a significant clearance problem, a different geometry should be attempted (stub length, smaller pressure angle, larger module).
3. Removing the mirrored copy, trimming and joining the involute and undercut curves as necessary, and then rotating them around (0,0,0) from their current location on the pitch circle to the left tooth guide.
4. Mirroring the curve again, and trimming it against the addendum circle, perhaps also dedendum circle, to create a complete tooth profile,
5. Creating a 360° polar array of tooth_count tooth profiles, centered around (0,0,0), trimming and joining them as necessary, and then offseting the entire gearwheel by 0.001 mm to the inside to minimize interference.
6. Cleaning up all the guides and helper circles except for the pitch circle.

Oh, here's one more thing: lowering tooth height, increasing module, or changing pressure angle are not the only tools to generate a machinable geometry when the standard output is not satisfactory: another trick is dubbed "profile shift". This last approach involves using a larger addendum circle, and a larger dedendum circle, on the pinion gear (the smaller of the two meshing gears); and doing the opposite on the larger one. My script lets you do this by varying the own_add and mating_add parameters in the command line: for example, specify own_add = 0.5, mating_add = 0.3 on the pinion gear, and own_add = 0.3, mating_add 0.5 on the other one, and compare the result to the default output from the script.

Spur gear with a given tooth height, width (module), pressure angle, and profile shift, will mesh properly with any other gear matching these parameters, regardless of the number of teeth. So, since the process of constructing gears tends to be time-consuming, consider creating libraries of common gear curves for easy reuse in other projects.

5.4. Other types of gears

Since both these gear types are largely impossible to machine without employing a rotary axis, and can be easily derived from spur gears, I will not be giving them too much attention; plastic spur gears are very quiet themselves when designed and lubricated properly, so there is seldom a need for these alternatives in normal applications.

Worm gears are another interesting type of a gear, this time relying on a rack tooth profile revolved around a spiral path (photo). Their primary benefit is a very high reduction ratio (one rotation of the shaft translates to advancing one teeth on the mating gear). Their primary disadvantage is that there is a fair amount of friction involved, resulting in poor efficiency (generally under 50%). Again, both of the mating gears need to be machined on a rotary axis (the mating gear is essentially just a low angle helical one); if need to make one of these, and have a difficulty figuring the geometry out, drop me a mail.

Lastly, we have bevel gears: a very useful device for changing the rotation axis (picture). These gears are constructed by first drawing two pitch circles in different planes, touching each other at the desired meshing angle (usually 90°), then finding the point where the axes of these circles, extruded perpendicular to their construction planes, intersect. For each of the wheels, a single tooth profile is drawn the usual way, and then rotated so that the plane of the tooth is perpendicular to a line extending from the aforementioned axis intersection point. The profile is then copied and scaled alongside this line fromt he intersection point, and the resulting two curves are lofted - producing a geometry like this. Unlike most other gears, any given bevel gear mates correctly only with its original counterpart.

5.5. Gearboxes and transmissions

In settings where horizontal space is at a premium, several independently rotating pairs of gears may be stacked on two nearby axles instead, transferring rotation back and forth (as seen here or here). A flat arrangement with one axle per gear in alternating orientations is also possible (image) - but requires at least three different gear sizes to be used to avoid interference, whereas the stacked design only requires two.

Planetary gears are another interesting, space-efficient approach; the most significant benefit of this spiffy design is that it's very compact, self-contained, and capable of transferring more torque due to multiple meshing points in every stage. Downsides include the need for extra complexity to actually constrain and interface every stage (example), requiring you to spend long hours on every individual case. The only new thing that appears in the planetary gearbox are the internal teeth on the ring gear: this is constructed by subtracting the addendum, and adding the dedendum, rather than the other way round; and then generating the involute curve under, not above, the pitch circle - and creating the undercut curve using an appropriately rotated rack.

Certain specialized types of transmission rely on racks, belts, or chains instead of round gears. Racks should be self-explanatory, with straight teeth at an angle equal to the pressure angle; making your own belts is relatively challenging, because the belt needs to be very flexible, but not stretchy. This is usually accomplished with the use of a polyurethane rubber backed with aramid cloth, and takes some serious trial and error to get right. Since there is no rolling action, belt tooth profile can be pretty much arbitrary (examples).

5.6. Drive systems

• Wheeled designs: this is definitely the best mode of locomotion to use while getting familiar with the dynamic properties of plastics, experimenting with sensors and microcontrollers, environment mapping algorithms, and so forth. Two basic wheeled movement systems are commonly employed:
  • Differential steering: one pair of wheels (rear or front) is hooked up to two separate motors, and the other pair of wheels is spinning freely. Driving in straight line is achieved by rotating the wheels at the same rate, while turns are implemented by making one of the wheels turn faster (example photo). In this design, two separate optointerrupters or rotary encoders should be used to monitor the free wheels, to detect loss of traction, and to compensate for the unintended differences in motor speed.
    This is a very simple system, and it has some disadvantages; most notably, unless difficult to instrument pivot wheels (or more user-friendly, but exotic omni wheels) are used, all turns result in the non-powered set of wheels being dragged sideways across the floor, causing significant friction (proportional to turn ratio, axle distance, and wheel contact area). This, in many cases, puts constraints on robot length, or the permissible turn radius.
    Three wheels can also be used instead of four, but this limits the amount of motion feedback the robot will be able to receive to just a single sensor; with treads or in two wheeled systems, dead reckoning gets a lot more difficult. Another interesting variant of a differential drive is the use of Mecanum wheels, where the problem of friction is largely eliminated; making these gizmos yourself is difficult, though, and the price tag on ready-made ones is rather steep ($100-$300 for a set of four).
  • "Proper" steering: in this arrangement, rear wheels are connected to a rigid axle (usually, a metal rod; non-round bars are often more convenient than smooth, round ones), and the entire assembly is powered by a single motor; front wheels are mounted so that they spin freely, and can also be turned in the X-Y plane (usually +/- 10-30°).
    Some linkage - for example, a rigid bar or symmetrical gearwheels - is then added to synchronize their turn angles (ideally using Ackermann geometry), and a position sensor plus a second motor is used to implement steering (example). A simple turn sensor is usually fitted with the front wheels to detect traction, too. This design - analogous to car steering - is fairly complex in comparison, and requires some familiarity with two-part molds and material properties to design a good way to attach the wheels and deal with the resulting shear stress - but offers superior performance and simply looks cooler.
    Turn angles possible with this mechanism are much higher than with differential steering, but when very high, some slippage may occur unless the speed of the outer rear wheel (traveling a larger circle) is higher than that of the inner one - especially in front-light robots. This can be corrected by using two rear motors - essentially combining the two steering systems - or with differential transmission on the rear axle.
• Legged robots: legged robots pose a lot of problems related to space management (fitting all the mechanisms within the envelope of a leg), torque requirements to actuate joints near their pivot point (you need 15 kg*cm of torque to lift a 1 kg load on a 15 cm leg), and - last but not least - designing practical movement algorithms. For these reasons, I do not recommend starting here, unless you intend to simply bolt a bunch of expensive servos onto a simple frame. That said, the usual arrangements are:
  • Biped robots: achieving a natural, stable walking gait probably requires at least 4-5 degrees of freedom per leg, packed in a very narrow envelope - as well as gyroscopes, accelerometers, and a bunch of contact or current sensors to detect problems early enough. Because of this, and because of the algorithmic complexity of biped motion, most of the designs you can see cut at least some corners - for example, using oversized feet to achieve static stability (example), or executing turns in awkward and inefficient ways (e.g., using series of small steps).
  • Quadruped and beyond: with four legs or more, it is quite easy to create a design capable of moving in any direction without the need for dynamic balancing. At least three degrees of freedom per leg are probably required to achieve efficient and useful walking gaits (making turns, climbing obstacles, etc - example layout), but some success on flat surfaces can be achieved with only two degrees (example). Hexapods seem to be particularly popular, perhaps because of their sinister look.
    A number of designs for scuttling robots with one or less than one degree for freedom per leg can be found on the Internet, but they are necessarily very limited (example), and essentially work like a wind-up toy.
• Other exotic designs: the list is pretty long - we have "pogo stick" hopping robots, ball-balancing devices, levitating (air cushion, magnetic fields, vibration) designs, flying, sailing, or crawling ones. I do not claim to have any experience with these, but it's clear that there can be no better way to impress the ladies - so tinker around.

6. Final words

If you have any questions, concerns, corrections, praise, or chocolate, please ping me at lcamtuf@coredump.cx. It would be cool to know that this guide helped at least one person, in any way :-)

Your lucky number: 8456251