Show BBpress topic tags from inside Wordpress.

I’ve been hosting a forum at http://diylilcnc.org using Wordpress and BBrpess integration, so that Wordpress and BBpress share user accounts. This is great for the most part; one drawback is that while you can use some of the Wordpress functions inside BBpress, you can’t go the other way and call BBpress functions from inside Wordpress.

For example, if you want to show a tag cloud with your forum’s topic tags on a Wordpress post or page, you  might try to use the function bb_tag_heatmap, but that function only works if you’re on a BBpress page. You might also think of trying wp_tag_cloud, but since Wordpress and BBpress are looking at different database tables for their tags, it won’t work either.

Here’s a pretty hacky way of making Wordpress show BBpress topic tags when you’re not on a forum page. I put the code below into my Wordpress theme’s sidebar.php.

global $wpdb;

$number_of_tags_to_show = 25;
$largest = 25; //largest font in points
$smallest = 4; //smallest font in points
$tag_page_url =  "http://www.mysite.org/forum/tags"; //url of your forum tags page

$taglist = $wpdb->get_results("select name, term_id from bb_terms","ARRAY_N");//$taglist[index][name][term_id]
for ($count = 0; $count < count($taglist); $count++)//use the term_id's to grab the count from bb_term_taxonomy {	 	if($taglist[$count][0])//if theres a tag term 	{ 		$query = "select count from bb_term_taxonomy where term_id = " . $taglist[$count][1]; 		$result = $wpdb->get_results($query, "ARRAY_N");
		$term_count = $result[0][0];
		$taglist[$count][2] = $term_count;
	}

} //now the array is formatted like so:  $taglist[index][name][term_id][count]

$taglist = sort2d($taglist, 2); //now the array is sorted with more popular tag at the front
$taglist = array_slice($taglist, 0, $number_of_tags_to_show);//truncate the array to show the correct number of tags
$taglist = sort2d($taglist, 0, 'asc', TRUE);//order the array alphabetically by tag

$min_count = 1;
$spread = 9;
if ( $spread <= 0 )
	$spread = 1;
$fontspread = $largest - $smallest;
if ( $fontspread <= 0 ) 	$fontspread = 1; $fontstep = $fontspread / $spread; while (list($tag_index) = each($taglist)) { 		 	$tag = $taglist[$tag_index][0]; 	$count = $taglist[$tag_index][2]; 	 	$fontsize = round( $smallest + ( ( $count - $min_count ) * $fontstep ), 1 ); 	$count > 1 ? $title = $count . " topics" : $title = $count . " topic";

	echo ''.$tag.' ';
	echo "\n";
}

function sort2d ($array, $index, $order='desc', $natsort=FALSE, $case_sensitive=FALSE)
{
   if(is_array($array) && count($array)>0)
   {
	 foreach(array_keys($array) as $key)
		$temp[$key]=$array[$key][$index];
		if(!$natsort)
		    ($order=='asc')? asort($temp) : arsort($temp);
	    else
	    {
		  ($case_sensitive)? natsort($temp) : natcasesort($temp);
		  if($order!='asc')
			 $temp=array_reverse($temp,TRUE);
	 }
	 foreach(array_keys($temp) as $key)
		(is_numeric($key))? $sorted[]=$array[$key] : $sorted[$key]=$array[$key];
	 return $sorted;
 }
 return $array;
}

Arduino-Controlled Crock Pot Yogurt Maker.

A homemade thermostat attachment for a crock pot (or other electric heating device). It can be used to precisely control the temperature of the crock pot for things like yogurt fermentation.

Why

• Making yogurt is fun. It is also way cheaper than buying it.
• You can make yogurt on the stove or in an oven, however it is fairly temperature-sensitive.
• I am lazy. I don’t like waiting around for the milk to sterilize; I usually end up burning it.
• I wanted to experiment with Arduino microcontroller programming (and Fritzing) to give myself a high degree of control over my fermentation process.

Why Not

• Electric yogurt makers already exist.
  • True, but many yogurt makers only incubate; the heating/sterilization has to be done by you on the stovetop.
• You can also buy crock pots with thermostats.
  • I know, wanna buy me one?
• You can buy yogurt in the store.
  • Yup. This is something I make for fun anyway. I figure I may as well combine it with other fun things I like.
• This is boring.
  • Mmm hmm. Maybe this will entertain you.

How

The crock pot is attached to a relay that can switch it on or off. The relay is toggled by a microcontroller based on readings from a temperature sensor (thermistor) placed inside the crock pot.

Here’s the basic yogurt recipe (and the detailed version):

1. Mix 1/2 gallon milk with 1 package of dry powdered milk. (This is optional, but it adds nutritional value and makes the yogurt thicker).
2. Heat the milk to 185°F (85°C). This kills off microbes to make way for our yogurt cultures, and denatures enzymes in the milk that may interfere with yogurt culture growth.
3. Cool the milk to 110°F (43°C). Add 2 tablespoons of already-made yogurt with active cultures, or yogurt starter.
4. In a sealed container, ferment the yogurt for 7+ hours by keeping it as close to 100°F (38°C) as possible.

Doing things the old-fashioned way, I’d be using a stovetop and candy thermometer for steps 2 and 3, then a warm oven or a radiator for step 4. That takes a lot of attention, and uses more containers than I care to wash later. Many commercially-sold yogurt makers still require you to perform step 2 yourself.

With the Arduino setup, I use a few canning jars in a water bath inside the crock pot to ensure even heating. I submerge  the temperature sensor in the water. A voltage divider circuit is used to indirectly measure the resistance of the thermistor. In the code, I make use of the Steinhart-Hart Thermistor Equation to translate the thermistor’s resistance into temperature. This gives a pretty good idea of the temperature inside the crock pot.

In addition to the thermistor’s resistance at a given time, the Steinhart-Hart equation needs to be fed three coefficients which can be calculated from information on the  manufacturer’s data sheet based on predetermined resistances at different temperatures. Since we’ll be measuring a range between 100°F (38°C) and 185°F (85°C), I used resistance values measured at 86°F (30°C), 140°F (60°C) and 194°F (90°C) to calculate my coefficients. Here’s a simple calculator to calculate your coefficients from a given temp/resistance range, and here’s a more in-depth explanation of the math involved.

Construction

Parts list:

• (1) Arduino Duemilanove USB-programmable microcontroller @ Sparkfun
• (1) Arduino ProtoShield Kit @ Sparkfun
• (1) Mini Breadboard @ Sparkfun
• (1) Relay Control PCB @ Sparkfun
• (1) Relay SPST-NO Sealed – 30A @ Sparkfun
• (1) Piezo buzzer or small speaker @ Sparkfun
• (3) Resistor 1k Ohm 1/4 Watt @ Jameco
• (1) Resistor 10k Ohm 1/4 Watt @ Jameco
• (1) Signal Diode (eg, 1N4148) @ Jameco
• (1) NPN Transistor (eg, 2N3904) @ Jameco
• (1) LED @ Jameco
• (1) 10K Thermistor @ Jameco
• (1) Moisture-Seal Heat-Shrink End Cap @ McMaster-Carr
• (6″-12″) Moisture-Seal Heat-Shrink Tubing @ McMaster-Carr
• (3″-6″) 1/4″ Inside Diameter Aluminum Tube @ McMaster-Carr
• (1) 120V AC Female Connector @ McMaster-Carr
• (1) Heavy-gauge 3-prong extension cord or power cable
• (1) Crock pot
• (2-3) Glass canning jars & lids (uniform size is ideal)
• You’ll also need some lead wire, a soldering iron and a multimeter.

Thermistor Preparation

Since the temperature readings will be taken in the water bath, we need a way to keep the thermistor from getting wet. Here’s a good reference for constructing a waterproof sensor.

Waterproof Thermistor.

I constructed my waterproof thermistor by first soldering the thermistor onto two long (~3′) lead wires, then wrapping the exposed wires with heat-shrink tubing. I slid a short length of aluminum tubing over the sensor, then used moisture-resistant shrink tubing to seal both ends. You could also use epoxy.

Relay Construction

Sparkfun.com has a great tutorial for constructing a 120V relay outlet specifically for this relay board. I recommend reading over their instructions.

Yogurt Maker Relay Assembly.

I deviated slightly by using a female connector instead of a GFCI outlet. Use the extension cord’s male end with about 12″-14″ of cord attached. Expose the three extension cord wires in the middle of the cord’s length. Cut the black wire and solder the ends to the relay board’s Load 1 and Load 2 connections. This is where the line voltage toggles on and off.

Relay Assembly: Black Wire is Soldered to Relay Board.

The three wires on the end of the cord attach to the female connector. The extension cord’s green/blue wire attaches to the green screw terminal. This is the ground wire. The black and white wires attach to the other two screw terminals. Use a connectivity tester to make sure that the larger slot receptacle is connected to the larger prong on the plug.

Female Connector Assembly: Green/Blue Wire Attaches to Green/Ground Screw.

Be careful when working with line voltage, as it can kill you. The solder points on the relay are basically live exposed wires, so use a project enclosure of some sort to keep the relay from accidentally being touched. I used a discarded plastic petroleum jelly container.

Circuit Building

Diagrams and schematics for the Arduino-controlled crockpot yogurt maker are shown below. If you haven’t yet, I’d also recommend checking out Fritzing, an open-source, cross-platform development a tool that allows users to document and share their electronics prototypes.

Yogurt Maker Fritzing Diagram & Schematic.

Fritzing offers a visual mode that allows circuits to be documented as they look in real life. This is a great feature for those of us who aren’t electrical engineers, or are just visual thinkers. The best part is that the visual mode is linked to a schematic drawn with traditional electronics symbols, which can really help electronics newbs to see the translation between visual circuit layout and schematic layout.

Yogurt Maker Circuitry Layout.

Yogurt Maker Circuitry Schematic.

Code

 /*
 Arduino-controlled crockpot thermostat, aka DIY yogurt maker.
 By Chris Reilly

http://www.rainbowlazer.com

 This program controls a relay that switches on an electric heating element (eg, crockpot) to control temperature for fermentation processes.
 The relay state is set based on readings from a thermistor which approximate the temperature of the heating element.
 The setup() function controls the stages of temperature for making yogurt.
 After adding powdered nonfat milk to liquid milk in glass canning containers, a water bath is set up in the heater, and the thermistor is placed in the bath.

 Stage 1 heats milk to 185F, to sterilize & denature enzymes in the milk.
 During this stage it's useful to cover the heating element with insulation such as towels to allow for faster/more efficient heating.
 The temp will hold at 185F for ten minutes, then stage one ends.
 At the end of stage one, the buzzer will signal for one minute.

Stage 2 cools the milk to 110F. During this stage it's useful to remove the cover and insulation from the heating element to allow for faster cooling.
As soon as the temp reaches 110F, the buzzer will signal. The temp will hold at 110F for ten minutes, then stage two ends.
Yogurt or starter culture is added and containers sealed at the end of stage 2.

Stage 3 incubates the yogurt at 100F for 8 hours. This time can be increased to taste and will result in more sour yogurt.
After holding, the heating element will be shut off. At the end of stage 3, the alarm will sound for 10 minutes, at which point the yogurt containers should be refrigerated.

 The serial monitor can be used for temperature readouts and feedback on what the program is doing.
 */

 #include <EEPROM.h>
 #include <math.h>

 // These constants won't change:
 const int sensorPin = 0;     // pin that the sensor is attached to
 const int relayPin = 13;    //pin that turns the relay on or off
 const int buzzerPin = 9;    //pin that activates the piezo buzzer
 const int buttonPin = 12;    //pin that activates the piezo buzzer

 //do a better job of getting temp
 double thermistor_read(int sensorVal) { 

     //Vout = Vin * (R2/(R1 + R2)) = analogread
     double R2 = 10000; //the other (non-thermistor) resistor in our voltage divider
     double R1;  //the resistance of\the thermistor (this will be calculated from the analog-to-digital conversion taken at the sensor pin)
     double temp;     //temp will be calculated using the Steinhart-Hart thermistor equation
     double Vin = 4.6;  //reference voltage that we get from the board

     double Vout = sensorVal * (Vin/1024); //convert the ADC reading from the analog pin into a voltage. We'll need this to calculate the thermistor's resistance next

     R1 = ((R2 * Vin) / (Vout)) - R2; //calculate resistance from the analogread value. See this page for more info: http://en.wikipedia.org/wiki/Voltage_divider

     temp = 1 / (0.0011690592 + 0.00023090243 * log(R1) + .000000074484724 * pow(log(R1), 3));
     //Steinhart-Hart thermistor equation, using coefficients calculated from the manufacturere's data sheet,
     //and the calculator found here: http://www.capgo.com/Resources/Temperature/Thermistor/ThermistorCalc.html
     //this gives us temperature in Kelvin

     temp = temp - 273.15;            // Convert Kelvin to Celcius
     temp = (temp * 9.0)/ 5.0 + 32.0; // Convert Celcius to Fahrenheit

     return temp;
 }

//convert millis to readable hours:mins:seconds
void timestamp(unsigned long milliseconds) {
   int seconds = milliseconds / 1000;
   int minutes = seconds / 60;
   int hours = minutes / 60;

   seconds = seconds % 60;
   minutes = minutes % 60;

   if (hours < 10)
     Serial.print("0");
   Serial.print(hours);
   Serial.print(":");

   if (minutes < 10)
     Serial.print("0");
   Serial.print(minutes);

   Serial.print(":");

   if (seconds < 10)      Serial.print("0");    Serial.print(seconds);  }  void printDouble(double val, byte precision) {   // prints val with number of decimal places determine by precision   // precision is a number from 0 to 6 indicating the desired decimal places   // example: printDouble(3.1415, 2); // prints 3.14 (two decimal places)   Serial.print (int(val));  //prints the int part   if( precision > 0) {
    Serial.print("."); // print the decimal point
    unsigned long frac, mult = 1;
    byte padding = precision -1;
    while(precision--) mult *=10;
    if(val >= 0) frac = (val - int(val)) * mult; else frac = (int(val) - val) * mult;
    unsigned long frac1 = frac;
    while(frac1 /= 10) padding--;
    while(padding--) Serial.print("0");
    Serial.print(frac,DEC) ;
  }
}

 //get to a specified temperature and hold
 //go_to_temp(target temp in F, duration in seconds to hold target temp for, whether to beep during hold time)
 boolean go_to_temp(double targetTemp, int holdFor, boolean alarm) { 

     //these need to be reset each time go_to_temp is called
     boolean tempReached = 0; //whether the target temp has been reached
     unsigned long startTime = 0; //the time in millis when the target temp is first reached
     int sensorValue = 0;         // the sensor value

     //loop the temp checking/relay control function until the target temp is reached, then hold for the amount of time specified in holdFor
     //the while statement will loop forever, until the target temperature is reached
     //once that happens, millis are used to count from startTime to startTime plus the length of holdFor
     while (millis() * tempReached <= (startTime + holdFor * 1000) * tempReached) {
       sensorValue = analogRead(sensorPin); //get the resistance reading from the thermistor

       if ((int)millis() % 1000 == 0){ //test the temperature every five seconds
            timestamp(millis()); //print the time elapsed since starting
            Serial.print("\tTarget temp = ");
            Serial.print(targetTemp, DEC); //print the desired temperature in F
            Serial.print("\tApprox Temp = ");
            printDouble(thermistor_read(sensorValue), 2); //print the approximate temp. in F
            Serial.print(" F");

            if (thermistor_read(sensorValue) < targetTemp) { //If below target temp, turn the crock pot on               digitalWrite(relayPin, HIGH);               Serial.print("\tRelay is ON");             }             else if (thermistor_read(sensorValue) > targetTemp) { //If above target temp, turn the crock pot off
                digitalWrite(relayPin, LOW);
                Serial.print("\tRelay is OFF");
            }

            if (abs(thermistor_read(sensorValue) - targetTemp) < 1) { //If approx. temp is within range of desired temp, log the time                 if (tempReached == 0) { //the tempReached boolean ensures this start time log only happens once                    startTime = millis();                    tempReached = 1;                 }             }              if (tempReached){ //if the target temp has been reached                     Serial.print("\tTarget temp reached at ");                     timestamp(startTime);                     Serial.print("\tholding for ");                     timestamp((startTime + holdFor * 1000) - millis());                     if (alarm)                       if (buzz(1) == 1) //buzz the buzzer to alert                         return tempReached; //if the temp is reached, and the buzzer buzzes, and the button is pushed, return true              }              Serial.println();        }     }     if (millis() * tempReached > (startTime + holdFor * 1000) * tempReached)
        return tempReached;
}

//make the buzzer generate a tone
void tone(int targetPin, long frequency, long length) {
    long delayValue = 1000000/frequency/2;
    long numCycles = frequency * length/ 1000;

    for (long i=0; i < numCycles; i++){                   // for the calculated length of time...
        if (micros() % (delayValue * 2) < delayValue)
            digitalWrite(targetPin,HIGH);                     // write the buzzer pin high to push out the diaphram
        else
            digitalWrite(targetPin,LOW);                     // write the buzzer pin low to pull back the diaphram
        }
}

//cycle the tone on and off for a given duration, in seconds.
int buzz(long duration) {
   long buzzEnd = millis() + duration * 1000;
   int buttonState = digitalRead(buttonPin);

   while (millis() < buzzEnd) {
         if (buttonState == HIGH) {
              if (millis() % 700 < 125) {
                   tone(9, 1500, 75);
               }
               else if (175 < (millis() % 700) && (millis() % 700) < 300)
                 tone(9, 1500, 75);
               else if (400 < (millis() % 700) && (millis() % 700) < 600)
                  tone(9, 1000, 75);
               buttonState = digitalRead(buttonPin);
         }
         else
             return 1;
    }

    return 0;
}

//Pretty much everything is controlled from setup(), since we don't want the looping that happens in loop()
//
void setup() {
     Serial.begin(9600); //open communications over the serial port @ 9600 baud
     pinMode(buzzerPin, OUTPUT); // set a pin for buzzer output
     pinMode(12, INPUT); // set a pin for pushbutton input

     /*
     Each one of these if statements below is one stage in the fermentation.
     */

     if (go_to_temp(185 /*temp(F)*/, (60 * 10) /*hold(seconds)*/, 0 /*to beep or not to beep during hold time*/) == 1) {//heat to temp (F) and hold for hold time (seconds)
         Serial.println();
         Serial.print("Stage 1 (Sterilize) Complete at ");
         timestamp(millis());
         Serial.println();
         Serial.println("Push button to advance.");
         Serial.println();
         buzz(300); //sometimes we want the alarm to happen after the hold time is complete, like in this case.
     }

     if (go_to_temp(110 /*temp(F)*/, (60 * 20) /*hold(seconds)*/, 1 /*to beep or not to beep during hold time*/) == 1) {//heat to temp (F) and hold for hold time (seconds)
         Serial.println();
         Serial.print("Stage 2 (Cool) Complete at ");
         timestamp(millis());
         Serial.println();
         Serial.println("Add yogurt/culture and seal containers.");
         Serial.println();
     }

     if (go_to_temp(110 /*temp(F)*/, 25200 /*hold(seconds)*/, 0 /*to beep or not to beep during hold time*/) == 1) {//heat to temp (F) and hold for hold time (seconds)
         Serial.println();
         Serial.print("Stage 3 (Incubate) Complete at ");
         timestamp(millis());
         Serial.println();
         Serial.println("Push button to stop buzzer.");
         Serial.println();
        // buzz(600);
     }
}

 void loop() { } //all our looping happens in individual functions

Making Yogurt

Wash Everything! Before starting, gather up all the containers, lids and stirring utensils to be used and thoroughly wash with hot, soapy water.

Ingredients: 1/2 gallon milk, 1 package dry milk, yogurt or starter culture. Let the yogurt come to room temperature before using; make sure that it contains live cultures & isn't expired!

Add the Dry Milk to the Wet Milk. Stir Thoroughly.

Fill Containers and Place in Water Bath in Crock Pot.

Insert the Thermistor in the Water Bath (Loosely cover jars to prevent condensation from dripping in).

Plug the Crockpot into the Relay, the Relay into a Power Source.

Cover the crockpot and insulate with towels or blankets to help the heating stage go faster. The milk will heat to 185° F.

Plug the Arduino into a Computer. The Serial Monitor will give Feedback and Instructions.

After the milk has cooled to 110° F, add starter or yogurt (about a tablespoon per container).

Seal the lids tightly and incubate for 7 hours (or more) at 100°F.

It's Yogurt! Refrigerate after opening.

This was a really cool project and seems to be successful. I’m hoping to continue and try some more interesting forms beyond text. I think cutting-edge fabrication technology is at it’s best when combined with established/non-digital techniques–it’s the best of both worlds!

This pour took place at the Butler Street Foundry in Chicago.

Laser-cut Form for Bronze Casting

The Final Product: A Cast Bronze Plaque

A Deep Raster Engraving With a Tapered Shoulder Makes for a Great Plaque Form

A Two-part Sand Mold Will Recieve the Molten Bronze

Casting Sand Packed into the Mold Holds an Impression of the Laser-cut Form

Casting Sand is a Mixture of Sand & Clay; Imagine the Best Sand-Castle Sand, Times Ten

A Gas Furnace is Used to Melt the Bronze

Solid Bronze Goes into the Furnace to Melt

Solid Bronze Goes into the Furnace to Melt

Lifting the Lid off the Furnace

The Molten Bronze is Lifted Out of the Furnace in a Container Called a Crucible

Molten Bronze Hoisted out of the Furnace

Molten Bronze Hoisted out of the Furnace

Molten Bronze in the Crucible

Molten Bronze Poured from the Crucible into the Two-Part Sand Mold

Molten Bronze Cools in the Two-Part Sand Mold: Weights are Placed on Top to Contain the Hydraulic Pressure Created in the Mold

After About 20 Minutes, the Bronze has Cooled Enough to be Released from the Two-Part Sand Mold

Bronze Casting Released from the Two-Part Sand Mold

The Final Product: A Cast Bronze Plaque

Laser cutting is a great technique for quick fabrication, in part because of the very small point size of the laser beam. The minuscule kerf of a laser cut allows for very tight 90° angles on interior (and exterior cuts).  This makes it easy to laser-cut thin panels of material for joining, as oomout demonstrates in this post on instructables.com (example pictured below). One of the drawbacks of laser cutting is the limited depth of materials that can be successfully through-cut; the laser cutter that I have access to can get through about 1/2″ of MDF or plywood, but the cuts are very charred and not perpendicular due to the hourglass shape of the laser’s focal point.

T-Bolt connection using laser-cut 1/4" panels

CNC routing is another great technique for quick fabrication. The range of material depth is much greater, there’s no burning, and through-cuts are perpendicular. One of the biggest drawbacks, however, is the inability to route interior corners due to the cylindrical shape of the cutting tool. This can require tedious hand-finishing to file or chisel out the interior corners to 90° angles, which is not worthwhile for projects that don’t have to look pretty, i.e. prototypes.

The technique pictured above is achieved by simply routing an extra bit of material out of interior corners to allow for 90° butt-joints. To set the paths for the corner knock-outs, a circle is created at each interior corner using a 3-point definition; the first point is set on the corner’s intersection, the second two are placed on each edge of the corner at a distance equal to the diameter of the router bit you plan on using. This will make sure enough material is taken away to allow for a 90° joint.

Vector path for 1/4″ laser-cut t-bolt joint (.dxf)

Vector path for 1/2″ CNC-routed t-bolt joint (.dxf)

It’s true! You can have multiple webcam feeds in your swf/as3 application. Here’s how:

1. Plug in your webcams.
2. Look in your Flash Player’s Camera Settings Panel. You might have to open an existing swf to get here. You should see a dropdown list of all the cameras available to you. The first camera on the list is camera 0, the second is camera 1, and so on. Remember the numbers of the cameras you want to work with (In my case, I want #7 and #8).
   
3. Call your cameras with Actionscript 3. Here’s the code, and here’s a FLEX project.
4. A few pointers: be careful about plugging/unplugging the cameras. Flash Player seems not to like this, you may have to quit and restart to refresh the list. You can adjust how and where both video feeds are placed in the scene. In this example they’re layered on top of each other with the blend mode set to OVERLAY, which [sort of] averages the two feeds together.
5. Only see one camera? Depending on your camera & drivers, your computer may not recognize two identical cameras at the same time. Cameras with different hardware should be recognized, though.

Also, I am using Playstation 3 Eye cameras, because they are great in low light and have high frame rates, and are pretty cheap. You can get drivers for Windows and Mac since they are not recognized automatically. Have fun!

Above is an example of varying speed settings with vector cuts and engravings on a 120W Co2 laser cutter. The ratios of power to speed are roughly the same on both groups of cuts, producing approximately the same depth; however one speed setting is much higher (30x) than the other, producing the wobbly lines on the fast group. The faster setting was enough to cause the laser’s Y axis to lose registration, as you can see on the two bottom lines of text.

Keeping a low speed is not necessary for all cuts, just those with small or intricate paths which cause the head to change position rapidly. Straight cuts with a higher speed usually look just fine.

Colors in the screenshots are only intended to distinguish between steps. Enjoy!

The final product should look something like this Webcam file with all steps (.3dm, 16mb)
Step 1.a Start a new file (small obj/inches)
Step 1.b In the Top viewport, draw 2 concentric circles, centered on 0, 1″ and 2″ diameters respectively.
Step 2 Copy and paste the smaller circle in place.
Step 3 Turn on Osnap and activate Cen only. Activate Move command, snap to Cen of copied small circle, then type <45 to add an angle constraint.
Step 4 Move small circle outward so that it intersects with the outer circle.
Step 5 Activate the ArrayPolar command. Select the small circle to array. Set 0 as the center of the array. Set the number of items to 4. Set the angle to 360. Hit Enter.
Step 6.a Select the four small circles. Activate the Split command, and split the large circle.
Step 6.b Select the large circle, then activate the Split command and split the four smaller circles.
Step 7 Select the four larger segments of the outer circle, and the four smaller segments of the outer circles–they’ll form a rounded cross-shape. Join these curves with the Join command.
Step 8 Turn on grid snapping. Select the innermost circle, and move it up one inch in the RIght or Front viewport by clicking and dragging.
Step 9 In the Front viewport, turn on grid Snap. Activate the Interpolate Points curve tool. To draw the first point, snap to the grid intersection on the x axis that is two inches to the right of zero. Then turn Snap off. Draw a line that is the approximate shape shown – it does not have to match perfectly. To draw the last point, turn Snap back on, and snap to the grid intersection that is 1″ above the x-axis and 1″ to the right of the z-axis.
Step 10 Select the curve you just drew, then activate the Offset command. Set the Distance to 0.04″, and offset below the original curve.

Taylor and I have been working on a DIY 3-axis CNC mill over the last few months. I’m posting this mostly to brag :), but also as an excuse to do some documenting on the process that might be useful to others. We’ll keep posting as things progress.

Some video of testing

The original plans use 1/2″ MDF for all the panels. We decided to go with with clear acrylic for the visual effect. Also, we were able to use a laser cutter for most of the cutting to the edges are nice and clean.  The downside is the brittle nature of acrylic, which likes to crack when drilled from the edge (and this design requires a lot of that).

CONTROLLER & CONFIGURATION

We’re using linux-based Enhanced Machine Controller to run the mill, with a modified version of the standard stepper configuration. Here’s our EMC configuration files. So far, I’ve been really pleased with the performance. It was trial-and-error figuring out the scaling– I ended up attaching a pencil to a dremel collet, then manually jogging each axis until I could draw a one-inch line in each direction. The scaling factors I came up with are: 520 for X and Y, and 16000 for Z, and that’s with quarter stepping set on the hardware controller board.

We kept getting a “Joint 2 Following error,” indicating that the z-axis was losing its position. I found that this was happening only when using  G00 (rapid-positioning) codes. I’m still a little unclear as to whether we need to even worry about positioning in this case, but for now I’m just replacing G00 codes in my toolpaths with G01 (linear motion). It’s a little slower, but for now the error is not happening anymore. See Feed Speeds for the permanent fix.

TOOLPATHS

We use Rhino3D and RhinoCam to generate our toolpaths. I’ve found that a number of different post-processors to work just fine, but mostly we’re using .NCD’s out of habit.

FEED SPEEDS

There doesn’t seem to be a way to directly set the feed and plunge speeds in EMC. The NCD post-processor defaults the feed speed to 3.7 and the plunge speed to 7.3 and the units are inches per minute. So we’ve been doing a search and replace in the post-processed files setting plunge to 14 and feed to 10 (this is easier than going back to RhinoCam to re-generate the toolpath with new feed speeds). We also then modified the MAX_FEED_OVERRIDE setting in the stepper_inch.ini file to 3, meaning we can increase the feed override up to 300%. We now limit the max override to 150%, and more deliberately set feed and plunge speeds in RhinoCam, under the Feeds & Speeds tab — these vary depending on material.

ERRORS

We kept getting a “Joint 2 following error” while testing, and found–after consulting the EMC documentation wiki–that changing the FERROR setting to 5.0 and the MIN_FERROR to 1.0 (that’s percent) for all axes in stepper_inch.ini alleviated this error. There’s the potential with increasing the FERROR settings of losing some accuracy, but that’s not our main concern at this point.