3D Printer Filament De-Humidifier Bin

Temperature/Humidity Sensors

The DIY/Robotics/Hobbyist market has spawned all sorts of new capabilities, so I was not at all surprised to find that temperature/humidity sensors were cheap and readily available. I started with the cheaper DHT11 (I figured I would kill at least one sensor before getting it right), but later moved on to the DH22. The DH11 humidity measurement range stops at 20% on the low end, and since I am trying to obtain humidities at or below that value, I decided to blow out my sensor budget from around $5/unit to around $10 – a real budget-breaker (not)!

DHT11 Temp/Humidity sensor, shown here from Adafruit. 20-80% RH range with +/- 5% accuracy

DHT22 Temp/Humidity sensor, shown here from Adafruit. O-100% RH range with +/- 2.5% accuracy

Arduino Uno Controller

In order to effectively use the RH sensors, I needed a controller of some sort. Happily for me, there was already a DHT11/22 library available for the wonderful Arduino line of controllers, and I happened to have several Arduino Uno’s lying around waiting for something to do. Connecting up the sensor, and getting a program working was a matter of just a few lines, most of which had already been written in the form of an example program

8-Character LCD Display

When I first started this project, I thought it would be adequate to simply connect the arduino to my PC to readout the data. This worked, but turned out to be cumbersome; I had to have a physical connection to the controller, which was located inside the dehumidifier bin. Later I tried a Wixel connection, which also worked, but still meant that I had to bring up a serial port app on my PC to find out what my dehumidifier bin was doing. What I really wanted was a completely self-contained system, so I could simply look at some sort of display on or in the bin and tell whether or not things were working. After doing a bit more web research, I found the Sparkfun ‘Basic 8-character LCD display’ for all of $4.95 (plus shipping). In addition, this display (plus a number of others with different character arrangements) were easily integrated into an Arduino program by means of the built-in ‘LiquidCrystal’ Library – nice!!

So now I had all the pieces – a sensor (DHT22), a controller (Arduino Uno), and a display for readout (Sparkfun 8×2 LCD). Now what I needed was a nice, custom-made box to house them, and just coincidentally I had 3D printer and LOTS of filament hanging around just waiting for a project! ;-). As usual, I went through several iterations (you would think that it would be pretty hard to screw up a simple box design, but I’m highly creative when it comes to finding new ways!). When I was finished, I had a nice little box with enough room for everything, a recessed lid, and appropriately placed holes for the power connector, the USB connector, and the sensor cable, as shown below

To complete the project, all I had to do was drill some holes in a handy transparent storage bin, load it up with filament rolls and a 40-watt trouble light, and set the sensor box inside where the readout would be visible from the outside. The whole thing was installed on a shelf over my workbench, so I can simply walk up to the bin and see the readout from eye level – neat!

Now all I have to do is wait a day or so to see where the system stabilizes, and make whatever airflow adjustments are necessary. For anyone who cares, I have included below the Arduino sketch for the project.

15 January 2017 Update: After 24 hours, the system stabilized to around 85 º F (29.4C) and about 26%, which I thought wasn’t enough better than room environment to make a difference, so I closed off about half of the air-holes. After another 24 hours or so, the system re-stabilized at about 90 º F (32.2C) and 21% humidity – much nicer!

17 February 2017 Cleanup: Here is the code to display temperature & humidity on the LCD display, and also make the data available at the serial port.



// DHT Temperature &amp; Humidity Sensor
// DHT Temperature &amp; Humidity Sensor
// Unified Sensor Library Example
// Written by Tony DiCola for Adafruit Industries
// Released under an MIT license.

// Depends on the following Arduino libraries:
// - Adafruit Unified Sensor Library: https://github.com/adafruit/Adafruit_Sensor
// - DHT Sensor Library: https://github.com/adafruit/DHT-sensor-library

#include&lt;LiquidCrystal.h&gt; // include the LCD library code:
#include&lt;Adafruit_Sensor.h&gt;
#include&lt;DHT.h&gt;
#include&lt;DHT_U.h&gt;

// initialize the library with the numbers of the interface pins
//01/07/17 gfp: my setup is:
//LCD pin name RS EN DB4 DB5 DB6 DB7
//Arduino pin # 7 6 5 4 3 2
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);

#define DHTPIN 8 // Pin which is connected to the DHT sensor.

// Uncomment the type of sensor in use:
//#define DHTTYPE DHT11 // DHT 11
#define DHTTYPE DHT22 // DHT 22 (AM2302)
//#define DHTTYPE DHT21 // DHT 21 (AM2301)

// See guide for details on sensor wiring and usage:
// https://learn.adafruit.com/dht/overview

DHT_Unified dht(DHTPIN, DHTTYPE);

uint32_t delayMS;
double tempF = 0; //holds temperature returned from DHT22
double RelHumPct = 0; //holds relative humidity returned from DHT22

void setup() {
Serial.begin(115200);

// Initialize Temp/Humidity sensor.
dht.begin();
Serial.println("DHTxx Unified Sensor Example");

// Print temperature sensor details.
sensor_t sensor;
dht.temperature().getSensor(&amp;sensor);
Serial.println("------------------------------------");
Serial.println("Temperature");
Serial.print("Sensor: "); Serial.println(sensor.name);
Serial.print("Driver Ver: "); Serial.println(sensor.version);
Serial.print("Unique ID: "); Serial.println(sensor.sensor_id);
Serial.print("Max Value: "); Serial.print(sensor.max_value); Serial.println(" *C");
Serial.print("Min Value: "); Serial.print(sensor.min_value); Serial.println(" *C");
Serial.print("Resolution: "); Serial.print(sensor.resolution); Serial.println(" *C");
Serial.println("------------------------------------");
// Print humidity sensor details.
dht.humidity().getSensor(&amp;sensor);
Serial.println("------------------------------------");
Serial.println("Humidity");
Serial.print("Sensor: "); Serial.println(sensor.name);
Serial.print("Driver Ver: "); Serial.println(sensor.version);
Serial.print("Unique ID: "); Serial.println(sensor.sensor_id);
Serial.print("Max Value: "); Serial.print(sensor.max_value); Serial.println("%");
Serial.print("Min Value: "); Serial.print(sensor.min_value); Serial.println("%");
Serial.print("Resolution: "); Serial.print(sensor.resolution); Serial.println("%");
Serial.println("------------------------------------");
// Set delay between sensor readings based on sensor details.
delayMS = sensor.min_delay / 1000;

// set up the LCD's number of columns and rows:
//lcd.begin(16, 2);
lcd.begin(8, 2);

// Print a message to the LCD.
//lcd.print("hello, world!");
//String str = "Temp: ";
//str += "43";
//lcd.print(str);
}

void loop()
{
// Delay between measurements.
delay(delayMS);

// Get temperature event and print its value.
sensors_event_t event;
dht.temperature().getEvent(&amp;event);
if (isnan(event.temperature))
{
Serial.println("Error reading temperature!");
}
else //good data
{
//12/07/16 temp is in C - convert to F
tempF = event.temperature * (9.0 / 5.0) + 32;
Serial.print("Temp/Humidity: ");
Serial.print(tempF);
Serial.print(" F\t");
}

// Get humidity event and print its value.
dht.humidity().getEvent(&amp;event);
if (isnan(event.relative_humidity))
{
Serial.println("Error reading humidity!");
}
else //good data
{
RelHumPct = event.relative_humidity;
//Serial.print(event.relative_humidity);
Serial.print(RelHumPct);
Serial.println(" %");
}

//// set the LCD cursor to column 0, line 1
//// (note: line 1 is the second row, since counting begins with 0):
//lcd.setCursor(0, 1);

//// print the number of seconds since reset:
//lcd.print(millis() / 1000);

//set the LCD cursor to column 0, line 0 (1st line)
lcd.setCursor(0, 0);
String str = "T: ";
str += String(tempF,1);
lcd.print(str);

//set the LCD cursor to column 0, line 1 (2nd line)
lcd.setCursor(0, 1);
str = "RH:";
str += String(RelHumPct,0);
lcd.print(str);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

// DHT Temperature & Humidity Sensor

// Unified Sensor Library Example

// Written by Tony DiCola for Adafruit Industries

// Released under an MIT license.

// Depends on the following Arduino libraries:

// - Adafruit Unified Sensor Library: https://github.com/adafruit/Adafruit_Sensor

// - DHT Sensor Library: https://github.com/adafruit/DHT-sensor-library

#include<LiquidCrystal.h> // include the LCD library code:

#include<Adafruit_Sensor.h>

#include<DHT.h>

#include<DHT_U.h>

// initialize the library with the numbers of the interface pins

//01/07/17 gfp: my setup is:

//LCD pin name RS EN DB4 DB5 DB6 DB7

//Arduino pin # 7 6 5 4 3 2

LiquidCrystal lcd(7, 6, 5, 4, 3, 2);

#define DHTPIN 8 // Pin which is connected to the DHT sensor.

// Uncomment the type of sensor in use:

//#define DHTTYPE DHT11 // DHT 11

#define DHTTYPE DHT22 // DHT 22 (AM2302)

//#define DHTTYPE DHT21 // DHT 21 (AM2301)

// See guide for details on sensor wiring and usage:

// https://learn.adafruit.com/dht/overview

DHT_Unified dht(DHTPIN, DHTTYPE);

uint32_t delayMS;

double tempF = 0; //holds temperature returned from DHT22

double RelHumPct = 0; //holds relative humidity returned from DHT22

void setup() {

Serial.begin(115200);

// Initialize Temp/Humidity sensor.

dht.begin();

Serial.println("DHTxx Unified Sensor Example");

// Print temperature sensor details.

sensor_t sensor;

dht.temperature().getSensor(&sensor);

Serial.println("------------------------------------");

Serial.println("Temperature");

Serial.print("Sensor: "); Serial.println(sensor.name);

Serial.print("Driver Ver: "); Serial.println(sensor.version);

Serial.print("Unique ID: "); Serial.println(sensor.sensor_id);

Serial.print("Max Value: "); Serial.print(sensor.max_value); Serial.println(" *C");

Serial.print("Min Value: "); Serial.print(sensor.min_value); Serial.println(" *C");

Serial.print("Resolution: "); Serial.print(sensor.resolution); Serial.println(" *C");

Serial.println("------------------------------------");

// Print humidity sensor details.

dht.humidity().getSensor(&sensor);

Serial.println("------------------------------------");

Serial.println("Humidity");

Serial.print("Sensor: "); Serial.println(sensor.name);

Serial.print("Driver Ver: "); Serial.println(sensor.version);

Serial.print("Unique ID: "); Serial.println(sensor.sensor_id);

Serial.print("Max Value: "); Serial.print(sensor.max_value); Serial.println("%");

Serial.print("Min Value: "); Serial.print(sensor.min_value); Serial.println("%");

Serial.print("Resolution: "); Serial.print(sensor.resolution); Serial.println("%");

Serial.println("------------------------------------");

// Set delay between sensor readings based on sensor details.

delayMS = sensor.min_delay / 1000;

// set up the LCD's number of columns and rows:

//lcd.begin(16, 2);

lcd.begin(8, 2);

// Print a message to the LCD.

//lcd.print("hello, world!");

//String str = "Temp: ";

//str += "43";

//lcd.print(str);

}

void loop()

{

// Delay between measurements.

delay(delayMS);

// Get temperature event and print its value.

sensors_event_t event;

dht.temperature().getEvent(&event);

if (isnan(event.temperature))

{

Serial.println("Error reading temperature!");

}

else //good data

{

//12/07/16 temp is in C - convert to F

tempF = event.temperature * (9.0 / 5.0) + 32;

Serial.print("Temp/Humidity: ");

Serial.print(tempF);

Serial.print(" F\t");

}

// Get humidity event and print its value.

dht.humidity().getEvent(&event);

if (isnan(event.relative_humidity))

{

Serial.println("Error reading humidity!");

}

else //good data

{

RelHumPct = event.relative_humidity;

//Serial.print(event.relative_humidity);

Serial.print(RelHumPct);

Serial.println(" %");

}

//// set the LCD cursor to column 0, line 1

//// (note: line 1 is the second row, since counting begins with 0):

//lcd.setCursor(0, 1);

//// print the number of seconds since reset:

//lcd.print(millis() / 1000);

//set the LCD cursor to column 0, line 0 (1st line)

lcd.setCursor(0, 0);

String str = "T: ";

str += String(tempF,1);

lcd.print(str);

//set the LCD cursor to column 0, line 1 (2nd line)

lcd.setCursor(0, 1);

str = "RH:";

str += String(RelHumPct,0);

lcd.print(str);

}

Frank

Evolution of a ‘Thank You’ Present

New Front Wheel Guards for Wall-E2

1 Reply

Posted 12/25/15

So, it’s Christmas day and I’m on a Southwest flight from Columbus, OH to Kansas City (via Chicago) to play in a bridge tournament. On the way, I’m taking the opportunity to work on my latest blog post. describing Wall-E2’s new front wheel guard design.

The impetus for front wheel guards comes from Wall-E2’s tendency to re-enact the ‘Tractor-tipping’ scene from the Cars’ movie. On occasion Wall-E2 encounters an obstacle like a chair leg with one front wheel or the other at just the right orientation so that it is able to climb up the leg with it’s 4-wheel drive, and, when it achieves a high enough angle, it’s relatively high CG does the rest. So, after the novelty wore off, I decided it was time to do something about the situation. After discussing options with my grandson Danny in a Skype session, we decided that two small wheel guards would probably work better than one big one, so that was the design direction we took.

In the year or so I have been working with TinkerCad and my 3D printing setup, I have learned that it is usually much faster and more effective to rapidly ‘evolve’ a design rather than trying to get it right the first time. A complete design-print-evaluate cycle only takes about 30 minutes, with negligible material cost, so why not!?

In the case of the front wheel guards, the design evolution went through about a half-dozen iterations, (not counting the initial one done ‘on the fly’ with Danny during the Skype session using my pocket knife and a section of a cardboard box). The ‘evolution of a modern wheel guard’ is shown in the following photo, proceeding from proto-guard on the left to fully modern wheel guard on the right.

Side view of guard installation with wheel removed for better visibility

Bumper evolution from ‘slime-mold’ to ‘fully evolved’ versions

The finished (as if anything is ever finished’ on Wall-E2) wheel guard is shown at the far right in the above photo, and the following shots show the installed result.

Side view of guard installation with wheel removed for better visibility

‘Fully Evolved’ wheel guard installed on left front wheel

Both wheel guards installed

I haven’t had a chance to try the new wheel guards out in practice, but I am quite confident they’ll do the job, and end Wall-E2’s short stint as a ‘Tractor-Tipping’ mimic! ;-).

Stay Tuned,

Frank

Glass Print Bed for Printrbot Simple Metal. Part V

3 Replies

Posted 12/17/15

In my last post on this subject I described my (ultimately successful) efforts to level my new glass print bed and disable Printrbot’s ‘auto leveling’ feature so I could get decent prints everywhere on my print bed.

During this project I had been posting results and questions on the ‘PrintrbotTalk’ forum (see this post), and one responder suggested the use of a cheap dial indicator from Harbor Freight to level the bed, independent of Printrbot’s Z-axis probe. After some initial missteps I was able to get one (item #623 on Harbor Freight’s website) and figure out a way to mount it on the extruder carriage. The following photos show the mounting arrangement, using the handy mounting tab on the back of the dial indicator.

Dial indicator mounted to the extruder carriage. Note ground-down portion of the carriage .

1/4″ by 1/4″ bushing fit nicely inside the 1/4″ I.D. mounting hole.

Dial indicator mounting tab and mounting screw/bushing

Dial indicator mounted, with carriage height adjusted to achieve a zero reading

With this arrangement, I was able to simply move the carriage around by hand, noting the needle excursions from zero. Then painter’s tape was added to the low side (or removed from the high side) to minimize the differential across the printing area. A 1mm height difference equates to about 40 small divisions on the indicator, and after shimming I was able to achieve a height differential of +/- 5 small divisions (about 0.125mm) across the print area.

After getting the glass plate all shimmed up, I decided that because I was no longer using the ‘auto-leveling’ (actually more like ’tilt correction’) feature, I could now remove the copper foil layer from beneath the painter’s tape – BIG MISTAKE!! On the very first test print after doing this, I realized to my horror that the Printrbot still needed to find the Z-axis ‘home’ position, and the only way to do that was with the Z-axis metal-sensing probe. Fortunately I was able to pull the power plug before the extruder tip had a chance to shatter my nice new glass plate!

After beating myself up for a while over such a bonehead move, I realized I had just two choices; I could laboriously replace the copper foil layer (one quarter-inch strip at a time), or I would have to find some way of replacing the metal-sensing probe with something else. I did not want to go through the agony of replacing the foil layer, so I was left (I thought) with option 2. Someone on PrinterbotTalk had mentioned a mechanical switch replacement for the Z-axis probe, and said there was at least one Thingiverse design for a bracket that mounted to one of the vertical carriage posts. I took a look at this and decided I could adapt it for one of the normally-open pushbutton switches I had in my electronics parts bins. After some further Googling, I realized that the replacement project might be a bit more involved than I originally thought, as there was an issue with later rev motherboards requiring a pullup resistor and some extra wiring to make the mechanical switch idea work.

Then I had an uncharacteristically brilliant idea, if I do say so myself. Rather than removing the Z-axis probe and replacing it with a mechanical switch mounted on the vertical slide assembly, why not combine the two ideas and simply mount the Z-axis probe itself on the vertical slide assembly? Then I get the best of both worlds – I don’t have to screw with the wiring at all, and the metal carriage base is perfect for the Z-axis probe to sense – voila!

Looking around a bit, I found that if I mounted the probe on the rear vertical slide post bushing, it would have a clear shot at a nice, flat open spot on the carriage base. All I needed was a right-angle bracket to attach the probe to the bushing. A few minutes in TinkerCad produced a printable design, and after a few minutes more I had the bracket printed up (I had to fake the Z-home a bit to get the bracket printed, but who’s counting). I super-glued the bracket to the slide bushing as shown in the following photo, and simply adjusted the height of the probe in the bracket so the extruder just ‘grabbed’ a sheet of printer paper when the Z axis was ‘homed’.

Z-axis probe relocated to the rear vertical post bushing

OK, so now I have a really cool glass print bed, with no ugly copper foil layer, and the Printerbot is no longer trying to murder my glass plate. I’ve only done a couple of test prints so far, mostly to figure out what M212 offset is required now with all the changes. However, I am looking forward to consistent prints with the new setup.

Stay tuned!

Frank

Glass Print Bed for Printrbot Simple Metal. Part IV

1 Reply

Posted 11/25/2015

In my last episode of “The Perils of Pauline” (aka Printrbot Simple Metal Glass Print Bed Issues), I described a set of measurements and print tests that ultimately led exactly nowhere, except maybe to the conclusion that Printrbot’s vaunted ‘Auto-leveling’ (more accurately ‘bed tilt correction’) wasn’t all that effective, and might even be part of the problem rather than part of the solution.

So, in this episode, I decided to manually level the glass print bed with painter’s tape shims, to see if I could get better prints that way. To do this, I used the existing Z-axis probe, the G29 ‘auto-level’ command, and the G30 ‘Z-axis probe here’ command. The G29 command tells the Printrbot to probe the Z-axis at three pre-configured points ( (10, 150), (10,10) and (150,10) in my case), and the G30 command tells it to probe the Z-axis wherever it happens to be (I used this to probe the bed at (150,10) – the rear right corner). Between these two commands, I could measure the print bed surface height at all 4 corners and adjust accordingly.

From previous measurements I knew that the bed tilted upwards from the rear to the front, and from left to right. Therefore I started out by moving the single layer tape shim from the front edge, and adding a single layer shim along the left edge. After three or four iterations, I wound up with two tape layers on the left and rear edges, and the resulting probe measurements were within 0.2mm everywhere. It’s hard to get much closer than that, due to variations in the probe results.

Initial painter’s tape shim layout

After getting the bed as level as I could, I ran another set of test prints. As shown in the photo below, all 5 positions printed successfully. I also noticed that the Z-axis worm gear moved noticeably less during print operations, providing an additional indication that the print bed was in fact pretty darned level.

All positions printed successfully, although the front right (Position 5) print was very lightly attached

When I removed the test prints from the bed, I noticed that the near-right (Position 5) print was less well attached than the others, and in fact the attachment quality improved as I went from Position 5 to 4 and then to 3. Positions 3, 2, and 1 (all in the same vertical line) seemed to all be nicely attached. So, the actual print results indicate that the extruder tip is getting farther away from the print bed as it progresses to the right, but the Z-axis probe measurements indicate the exact opposite situation – the print bed actually gets higher as it goes from left to right! How can this be? Well, based on everything I have learned to date, I now strongly suspect that the answer is that the tilt correction algorithm is correcting the wrong way somehow. Maybe the fact that the Printrbot’s ‘home’ position is at (Xmin, Ymax) rather than (Xmin, Ymin) is causing a sign error somewhere, and this is causing the Printrbot to correct the Z-axis up for movements in the positive X and negative Y directions when it should be correcting it down. This theory tracks with what I have experienced so far, as it would imply that the closer I can get the plate to absolute level, the smaller the error would be, ultimately going to zero error for a perfectly flat plate. Of course, if I’m right, I should be able to somehow track down and correct this sign issue, and therefore convert what is now a force for evil into a force for good – arggghhhh!!!!

Late addition: After posting this to the ‘Printrbot Talk’ forum, I got a note from ‘Retiree Jay’ to the effect that I could disable the tilt correction function entirely by omitting the ‘G29’ command from the startup script, leaving only the ‘G28 X0 Y0 Z0’ command. So, I did this and ran another series of test prints as shown in the following photo. As you can see, all prints were successful, even the added Position at the right rear of the print bed. And even better, Retiree Jay was correct in that the Z-axis motor did not run at all (up or down) during prints of a specific layer (since I printed only one layer for each position, this means that the Z-axis motor didn’t run at all during the entire print series. This pretty much proves that my new glass plate is flat across the entire print area; “Tilt Correction? We don’t need no stinkin Tilt Correction!” ;-))

Print series with tilt correction disabled. “Tilt Correction? We don’t need no stinkin Tilt Correction!”

Stay tuned,

Frank

Glass Print Bed for Printrbot Simple Metal. Part III

1 Reply

Posted 11/24/2015

A few days ago I posted a long account of my attempt to add a glass plate printing surface to my Printrbot Simple Metal, to address printing problems due to non-planar warping issues with the original print bed. As described in the post, I was able to satisfy myself that the glass plate was much flatter than the original bed, but I still couldn’t get consistent prints except in a very small area – printing the same part at the same Z-axis offset resulted in either a print that wouldn’t adhere, or gouges in the painter’s tape. My conclusion at the time was that maybe the vaunted ‘auto-leveling’ feature (actually just 3-point tilt correction) has been inadvertently disabled in my firmware version, or maybe it wasn’t ever functional in the first place.

So, in this post I describe my efforts to manually level the glass plate print bed. Based on the results from the previous post, I know that the bed must slope downward from the back to the front, as the print was more or less OK at the back, but became separated from the bed as the print positions progressed toward the front. So, I put down a layer of painter’s tape underneath the glass plate at the front edge of the original print bed, and then ran the same series of prints, starting at the rear right corner as before.

The following two photos show the painter’s tape shim installation

Painter’s tape shim installation

With this setup, I started by printing the 20mm cal cube at the extreme left rear corner of the print area, what I’m calling ‘Position 1’. The first print failed partway through when the piece detached from the bed, indicating the Z-axis offset was too high, at Z = -1.1. This was interesting all by itself, as Z = -1.1 was the offset I used for the entire first experiment a few days ago; I speculate that the addition of the painter’s tape shim may have lowered the plate very slightly at the back corner. I changed the offset to Z = -1.2, and this gave me a good Position 1 print, as shown below.

Position 1 print with Z = -1.1. Note the detachment

Position 1 print with Z = -1.2

Then I moved on to Position 2 (still at extreme left edge, but midway from back to front) and tried again. As shown in the following photo, I got a good print here as well.

Position 2 print with Z = -1.2

From there I moved on to Position 3 (extreme front left corner of the print area), and Position 4 (front edge, midway from left to right). As shown in the following photo, I got a very good print at Position 3, but the Position 4 print detached immediately.

Positions 3 and 4. Position 3 printed OK, but Position 4 detached immediately

So, it appears at the moment like I have the plate leveled in the front-to-back direction, but not in the left-to-right direction. Next I’m going to try adding a layer of tape from front to back at the extreme right edge and see what this does. Note in all this that Printrbot’s ‘Auto-level’ feature should already be compensating, but it appears to be AWOL.

With one layer of tape added, I was still getting very poor results in the X (left to right) direction, so I added a second layer of tape. After this, I was able to get all 5 prints to stick, although as the photo below shows, the last two were ‘iffy’

With two layers of tape front to back at the extreme right edge

So, I added a third layer of tape, and ran another print series, and got almost identical results! How can this be? I’ve added three layers of tape, and I’m still not able to print in the near right-hand corner – this just doesn’t make any sense.

OK, the only possible way it could make any sense at all, is if the Printrbot ’tilt-correction’ algorithm IS enabled, but not functioning correctly, either due to the algorithm itself, or due to incorrect Z-axis sensor readings from the probe. So did another test print, but this time I concentrated solely on the Z-axis servo worm gear. At first I simply put my fingers on the worm gear so I could feel if there was any Z-axis movement during lateral head moves, and sure-nuff, there was some! Then I put a painter’s tape ‘flag’ on the worm gear and I can easily see Z-axis movement during even small lateral head moves. The clear indication is that the tilt-correction algorithm is working, but for prints near the right-hand edge of the print bed, the correction is wrong. I wonder if the errors are due to scaling based on inaccurate print bed dimensions in the printer setup dialogs; this would seem inconceivable, but what do I know?

On a recent print at the near right edge, with 3 layers of tape, the probe measurements were:

(10,143,1.46), (10,10,1.79), (143,10,2.32)

with the tape removed, the measurements are

(10,143,1.35), (10,10,1.59), (143,10,1.94).

This seems to indicate that positive Z is ‘up’ and that lower positive Z values indicate a surface that is actually closer to the bottom of the printrbot. This, in turn, should mean that I could achieve what I want by putting tape under the left edge, not the right, even though the print performance indicated just the opposite! Oh, I have a headache!

with the right-edge 3-layer tape shim removed entirely, I re-ran the original test print series. Instead of the mess I got the first time, printing at all 5 positions succeeded as shown in the following photo – huh?????

All three tape shim layers removed from the right edge

OK, so this just should not be happening! When I started this post, with no shimming at all, I could print to position 1, 2 & 3 (along the left edge, from rear to front), but not positions 4 or 5 (along the front edge, from left to right). This behavior is what led me to shim along the right edge, but although I thought I was making the situation better, increasing the shim height from 2 to 3 layers didn’t help at all, and now I find that with no shim layers I get really nice prints at all 5 positions – what gives?

Thinking back through everything I did this evening, I realized there was one thing I did that could maybe have affected the situation – I changed the printer extents via the Repetier ‘Printer Settings’ dialog. This should not affect tilt correction calculations at all, since the Printrbot already knows the absolute coordinates for all three Z-axis probe points, so why would it care (or even know) what extents have been set in Repetier?

As a test of this wild and zany idea, I set the Y-Max value in Repetier to 350, basically twice what it should be, and set up for another print series. When the probe results came in, they were:

(10,143,-1.06), (10,10,-0.85), (143,10,-0.5) – whoa! How can that possibly be? Clearly there is some coupling from the values set in Repetier’s Printer Settings dialog, but why?

For position 2, the Z-axis probe reports (10,143,1.42), (10,10,1.56), (143,10,1.90)

– Oh, now I have an even bigger headache! How can this be? Negative values one time, and positive values the next – with exactly the same hardware and software configuration (including the same – bogus – Y Max value)??

For position 3, I get: (10,143,1.46), (10,10,1.72), (143,10,2.03) – print was fully successful

For position 4, I get: (10,143,1.44), (10,10,1.70), (143,10,2.02) – print was successful, but marginal

For position 5, I get: (10,143,1.44), (10,10,1.71), (143,10,2.02) – print fully successful

All three tape shim layers removed from the right edge

OK, I give up – I’m officially baffled. Everything I have done has had either no effect, or an effect opposite to what I expected. Then returning the experimental setup to its baseline condition did not restore baseline results – WTFO@!!@#$%^&*(

Frank

3D Printed Terminal Strip Cover/LED Bracket

Glass Print Bed for Printrbot Simple Metal – Part II

2 Replies

Posted 11/19/2015

A week or so ago I posted an account of my attempt to add a glass plate to my Printrbot Simple Metal print bed. I thought I had a great idea – place patches of copper foil tape on top of the glass plate at the three points where the Z-axis probe sensor checks for print bed tilt (it’s called auto-leveling, but it is actually more like auto-tilt correction), and everything should be groovy. Unfortunately, what I thought would happen and what actually happened were two different things. It appeared that either tilt correction wasn’t being applied at all, or it was being applied, but in the wrong direction (which doesn’t make any sense either, because I didn’t change anything except adding the glass plate).

So, I decided to make another run at the problem. My new approach was three-fold; first, I took some time to thoroughly investigate the flatness of the original Printrbot print bed, and the flatness of the glass plate. Second, I decided to cover the entire glass plate with copper foil, not just the small areas used by the Z-axis sensor. Third, I figured out a way (the ‘G30’ command) to take Z-axis sensor reading at multiple spots on the print plate, rather than just the 3 points used in normal printing, so I could really determine how well the Z-axis sensor itself behaved.

Printrbot print bed and glass plate flatness investigation:

I used two different techniques to evaluate the flatness of both the original Printerbot print bed and the glass plate addition. The first technique was to place a light source so that it illuminated the bed from the side, and look for light leakage under a straight-edge placed on the bed. The second technique was to use a piece of printer paper (approx 0.09 mm thickness) to see if there were any areas where the paper would slide freely under the straight edge. The photos below show the result for both the original print bed and the glass plate. The first image shows the setup, with an LED flashlight placed so it shines light parallel to the surface, with a steel straight-edge blocking the beam except where the bed is warped. Subsequent photos show warped areas.

Flashlight shining along surface of print bed, with steel straight-edge blocking light except where the bed is warped.

Next I did the same thing with the glass plate, as shown in the following images.

The glass plate is clearly much flatter than the original print bed. I verified this using the paper technique – I was able to easily slide a piece of 0.09 mm paper under the straight-edge on the original print bed, but not on the glass plate. So, as far as flatness is concerned, the glass plate is a clear winner.

Z-Axis Probe Measurements

Since I was now convinced that the glass plate was much flatter than the original print bed, this issue could not be the reason I was having so much trouble trying to get reliable prints at different points on the print bed. So, I turned my attention to the only other possible factor, the Z-axis probe itself. If it was somehow producing aberrant readings, maybe that would explain why the Z-axis offset required for printing at the near right corner was wildly inappropriate for the same print in the back left corner. To acquire the data I made use of the G-code ‘G30’ command, which causes a Z-axis probe operation at the current X/Y location. I recorded Z-axis probe readings at 12 locations on the glass plate, and plotted the results using Excel’s ‘Surface’ plot feature

Z-axis probe sensor readings for glass plate

11/20/15 Glass Plate Z-axis probe sensor results

As can be seen in both the data and the surface plot, the glass plate is pretty flat – with only a 0.42 mm deviation from one extreme from the other.

The same set of measurements were performed on the original Printrbot metal print bed, with the following results:

11/20/15 Original print bed Z-axis probe results

The data shows that the original print bed is pretty flat too, even though the illumination experiment showed that it exhibits significant warping. I suspect that the probe measurement locations were too widely spaced to capture the low spots. In any case, all that can be said for sure at this point is that both surfaces (original print bed and glass plate) are pretty flat, and both exhibit some tilt, with Z-axis probe measurements consistently rising from the left rear corner (0,153) to the front right corner (130,3).

Print Trials:

After convincing myself that the glass plate was indeed flat, and that any residual tilt should be well within the Printrbot’s correction range, I decided to do a series of test prints – starting at the rear left corner and moving toward the near right corner. For the first print, I adjusted the Z-offset for optimum printing – not too close, not too far away. Then I kept this same Z-offset for all the other prints. The following photos tell the story.

20mm cal cube printed at the rear left corner (0,153)

20mm cal cube printed at (0,103)

First try at printing 20mm cal cube at the third position (0,53). Note the blob attached to the extruder!

2nd try at printing 20mm cal cube at the third position (0,53). Note the raised corner

20mm cal cube printed attempt at the near right corner. Part is separated from the bed and ‘blobbed’ to extruder and

20mm cal cube printed at the rear edge, midway toward the right

20mm cal cube print attempt at the rear right corner. Part has separated from bed and is ‘blobbed’ to extruder.

So, at this point I’m pretty sure of three things:

The glass plate print bed is pretty darned flat
The Z-axis probe seems to be working correctly
The Printrbot tilt correction feature does not appear to be working properly.

Stay tuned,

Frank

Wall-E goes back to basics; Ping sensors and fixed forward-facing LIDAR

2 Replies

Posted November 14, 2015

Back in the spring of this year I ran a series of experiments that convinced me that acoustic multipath problems made it impossible to reliably navigate and recover from ‘stuck’ conditions using only acoustic ‘ping’ sensors (see “Adventures with Wall-E’s EEPROM, Part VI“). At the end of this post I described some alternative sensors, including the LIDAR-lite unit from Pulsed Light.

In this same article, I also hypothesized that I might be able to replace all the acoustic sensors with a single spinning-LIDAR system using another motor and a cool slip-ring part from AdaFruit. In the intervening months between April and now, I have been working on implementing and testing this spinning LIDAR idea, but just recently arrived at the conclusion that this idea too is a dead end (to paraphrase Thomas Edison – “I have not failed. I’ve just found 2 ways that won’t work.”). I simply couldn’t make the system work. In order to acquire ranging data fast enough to keep Wall-E from crashing into things, I had to get the rotation rate up to around 300 rpm (i.e. 5 rev/sec). However, when I did that, I couldn’t process the data fast enough with my Arduino Uno processor and the data itself became suspect because the LIDAR was moving while the measurement was being taken, and the higher the rpm got, the faster the battery ran down. In the end, I realized I was throwing most of the LIDAR data away anyway, and was paying too high of a price in terms of battery drain and processing for the data I did keep.

So, in my last post on the spinning-LIDAR configuration I summarized my findings to date, and described my plan to ‘go back to basics’; return to acoustic ‘ping’ sensors for left/right wall ranging, and replace the spinning-LIDAR system with a fixed forward-facing LIDAR. Having just two ‘ping’ sensors pointed in opposite directions should suppress or eliminate inter-sensor interference problems, and the fixed forward-facing LIDAR system should be much more effective than an acoustic sensor for obstacle and ‘stuck’ detection situations.

Over the last few weeks I have been reworking Wall-E into the new configuration. First I had to disassemble the spinning LIDAR system and all its support elements (Adafruit slip-ring, motors and pulleys, speed control tachometer, etc). Then I re-mounted left and right ‘ping’ sensors (fortunately I had kept the appropriate 3D-printed mounting brackets), and then designed and 3D-printed a front-facing bracket for the LIDAR unit. While I was at it, I 3D-printed a new left-side bumper to match the right-side one, and I also decided to retain the laser pointer from the previous version. The result is shown in the pictures below.

Wall-E after being stripped down for remodeling.

Oblique view showing the new fixed front-facing LIDAR installation, complete with laser pointer.

Side view showing both ‘ping’ sensors. Note the new left-side bumper

After getting all the physical and software rework done, I ran a series of bench tests to test the feasibility of using the LIDAR for ‘stuck’ detection. I was able to determine that by continuously calculating the mathematical variance of the last 50 LIDAR distance, I could reliably detect the ‘stuck’ condition; while Wall-E was actually moving, this variance remained quite large, but rapidly decreased to near zero when Wall-E stopped making progress. In addition, the instantaneous LIDAR measurements were found to be fast enough and accurate enough for obstacle detection (note here that I am currently using the much faster ‘Blue Label’ version of the LIDAR-Lite unit).

Finally, I set Wall-E loose on the world (well, on the cats anyway) with some ‘field’ testing, with very encouraging results. The ‘stuck’ detection algorithm seems to work very well, with very few ‘false positives’, and the real-time obstacle detection scheme also seems to be very effective. Shown below is a video clip of one of the ‘field test’ runs. The significant events in the video are:

14 sec – 30 sec: Wall-E gets stuck on the coat rack, but gets away again. I *think* the reason it took so long (16 seconds) to figure out it was stuck was because the 50-element diagnostic array wasn’t fully populated with valid distance data in the 14 seconds from the start of the run to the point were it hit the coat rack.
1:14: Wall-E approaches the dreaded ‘stealth slippers’ and laughs them off. Apparently the ‘stealth slippers’ aren’t so stealthy to LIDAR ;-).
1:32: Wall-E backs up and turns around for no apparent reason. This may be an instance of a ‘false positive’ ‘stuck’ declaration, but I don’t really know one way or the other.
2:57: Wall-E gets stuck on a cat tree, but gets away again no problem. This time the ‘stuck’ declaration only took 5-6 seconds – a much more reasonable number.
3:29: Wall-E gets stuck on a pair of shoes. This one is significant because the LIDAR unit is shooting over the toe of the shoe, and Wall-E is wriggling around a bit. But, while it took a little longer (approx 20 sec), Wall-E did manage to get away successfully!

So, it appears that at least some of my original goals for a wall-following robot have been met. In my first post on the idea of a wall-following robot back in January of this year, I laid out the following ‘system requirements’:

Follow walls and not get stuck
Find and utilize a recharging station
Act like a cat prey animal (i.e. a mouse or similar creature)
Generate lots of fun and waste lots of time for the humans (me and my grandson) involved

So now Wall-E does seem to follow walls and not get stuck – check. It still cannot find/utilized a charging station, so that one has definitely not been met. With the laser pointer left over from the spinning-LIDAR version, it is definitely interesting to the cats, and one of them has had a grand time chasing the laser dot – check. Lastly, the Wall-E project has been hugely successful in generating lots of fun and wasting lots of time, so that’s a definite CHECK!! ;-).

Next Steps:

While I’d love to make some progress on the idea of getting Wall-E to find and utilize a charging station, I’m not sure that’s within my reach. However, I do plan to see if I can get my new(er) 4WD chassis up and running with the same sort of ping/LIDAR sensor setup, to see if it does a better job of navigating on carpet. Stay tuned!

Frank

Glass Print Bed for Printrbot Simple Metal

2 Replies

Posted 11/08/2015

I’ve been having some problems lately getting good prints on my Printrbot Simple Metal 3D printer, and after a lot of inet research I concluded the problem was a warped print bed. The bed that comes with the Simple is pretty nice, but just not thick enough IMHO to avoid some warping. And once the bed becomes even a little bit non-planar, then the very nice ‘auto-leveling’ (more accurately ‘bed tilt compensation’) ceases to be very useful.

There was some discussion about putting a glass plate down over the original bed, which takes care of the non-planar issue, but then the Hall-effect metal bed sensor can’t ‘see’ the metal print bed through the glass plate, unless the glass plate is too thin to do any good. What to do?

I’m a long-time Electrical Engineer and antenna researcher, and so it occurred to me that I might be able to fake out the bed sensor by applying some adhesive-backed metal tape to the top of a glass plate, thereby establishing a new ‘zero’ reference at the top surface of the glass plate. I ran some simple experiments, and found that the bed sensor worked fine with even very thin strips of just about any metal, including copper. Since I knew I could get copper tape in various thicknesses and widths, I thought this idea might be worth a try.

The glass plate:

I remembered seeing a post somewhere that someone had found that a popular picture frame size worked just great for the Printrbot Simple Metal print bed, so I headed over to my local JoAnne’s fabric to see what was available. I found lots of cheap picture frames in various sizes, but nothing that even remotely approached a good size for my print bed – bummer. So, I decided to go the custom route, and, after carefully measuring my bed, got a piece of 3/32″ (~2.3mm) glass cut to 9.5 x 6.5″. I brought the piece home and carefully smoothed the edges with my belt sander (a sander drum attachment for a drill would work also). Unfortunately, when I laid the piece on my print bed, I discovered I had screwed up – the 9.5″ dimension was slightly too large, and the pieced didn’t quite fit between the two sets of mounting screws. I was really bummed out, until I realized I might be able to recover from this disaster by simply grinding cutouts for the screwheads, thereby converting a ‘bug’ into a feature! ;-). Indeed I was able to do this with a Dremel tool and a small grinding bit, and when I was finished I had a nice, self-registering glass plate for my Printrbot!

Screw head cutouts ground with Dremel tool and small grinding bit

The Sensor Tape:

I didn’t have any adhesive backed copper tape handy (I used this stuff by the roll in my prior life as a research scientist, but didn’t think to take any with me into retirement), so I tolled the net for a while for sources. I finally wound up ordering a 10′ roll of 1/4″ adhesive-backed copper tape from eBay

Assembling the new Print Bed:

I used heavy-duty document clips to hold the glass plate down on the original print bed, and then placed copper tape patches at the X/Y home location and the two ‘slope compensation’ sensing points, and then covered the entire thing with blue painter’s tape to provide the same first-layer adhesion as before.

Testing:

I used a 20mm hollow cal cube as my test object, starting at a point near the X/Y home position. As expected, I had to adjust the Z offset some, and wound up with a Z offset of about -0.8 to get a decent print.

Then I tried moving the cube around on the print bed, and found that I had to keep moving the Z offset further negative as I moved the print position away from the X/Y home position. To get the cube to print properly, I would up with a Z offset of -2.0mm, way more than I had expected, and then when I tried to move the print back to near the X/Y origin with the same Z offset, I got the extrusion drag marking shown – bummer!

After seeing the above problem occur, I tried to figure out what was going wrong, and having a heck of a time with it. Here’s what I know:

The Z offset required to get decent first-layer adhesion gets markedly more negative the further away the print position is from the X/Y home position
Trying to print near the X/Y home position with the Z offset required for a position far away from X/Y home causes extrusion head dragging.
However, in a somewhat contradictory finding, if I manually move the extrusion head position arm (the Y axis, I think) toward the outer edge of the print bed, it starts to drag about halfway across for X values near home, and this condition becomes more marked when the bed is manually moved in the positive X direction (to the left looking at the front of the printer). In other words, when moving the extrusion head in manual mode, it appears the print bed has a marked upward slope as X & Y increase, causing significant head drag. However, when printing, the opposite effect seems to occur, where the print bed appears to have a marked downward slope as X/Y increase. This makes no sense at all!

So, at the moment I’m officially baffled. In manual mode, the printrbot behaves as if the bed is sloped upward as X & Y increase, but in printing mode (where I assume the ’tilt compensation’ is in effect), the printrbot behaves as if the bed is sloped in the opposite direction. What gives!?

More to come (I hope)