The Smell of Molten Projects in the Morning

Ed Nisley's Blog: Shop notes, electronics, firmware, machinery, 3D printing, laser cuttery, and curiosities. Contents: 100% human thinking, 0% AI slop.

Category: Software

General-purpose computers doing something specific

  • SJFW: Initial EEPROM Configuration File

    Starting with acceleration and speed values based on those initial estimates, I hand-fed G-Code moves directly into the printer via pronsole while bouncing among these choices:

    • Increase acceleration until motor stalls
    • Decrease acceleration until motor starts
    • Increase velocity until motor stalls
    • Decrease velocity until motor runs

    The X axis runs fine at 333 mm/s = 20 m/min with 20 m/s2 acceleration; that little motor isn’t an impediment at all. As expected, the Y axis can’t accelerate that hard; it eventually started at 10 m/s2 to run at 250 mm/s = 15 m/min. I set X = 15 m/s2 and Y = 5 m/s2, with different maximum speeds.

    With those values in place, the printer can run the Smooth Axis Test at 250 mm/s, which is breathtaking and surprisingly noise-free: acceleration control eliminates the jarring start-stop motion. I modified Jackson’s G-Code to remove position testing, which uses codes that SJFW doesn’t implement.

    It’s worth mentioning I haven’t adjusted the motor currents at all.

    The Z axis can run at 2000 mm/min = 33 mm/s with acceleration around 1500 mm/s2. I backed that off to 1500 mm/min = 25 mm/s with 1000 mm/s2 acceleration. It’s noticeably faster than before, but that really doesn’t make much difference; there’s no point in replacing the stock MBI high-resistance / high-inductance motor.

    The E axis seems to require setting its speed with a separate G1 Exxx command (which is how Skeinforge does it) to get consistent results, although I confess to not taking good notes. I disconnected the filament drive to run the motor / gears without a load, got a workable speed & acceleration combination, reconnected the drive, fired up the hot end, and squirted filament all over the place to get actual numbers. It turns out that the little stepper on the extruder can actually ram a few millimeters of filament into the hot end at 4000 mm/min = 66 mm/s, but with acceleration down at 250 mm/s2. That’s dramatically peppier than the previous pace, which should reduce the Reversal Zittage problem.

    The resulting SJFW config file, with many unchanged default entries, will not work on a stock Thing-O-Matic:

    ; TOM286 with Z-min switch
M402                            ; Write this config to EEPROM
M309 P1 S0                      ; Endstops
M300 X28 Y25 Z22 E15            ; STEP pins
M301 X27 Y24 Z17 E14            ; DIR pins
M302 X26 Y23 Z16 E3             ; ENABLE pins
M304 X12 Y10 Z8                 ; MIN pins
M305 Z7                         ; MAX pins
M307 X1 Y1 Z0 E1                ; Axis Inversion
M308 X0 Y0 Z0 E0                ; Disable After Move
M200 X47.06985 Y47.06985 Z200  E48.30 ; Steps per MM
M201 X1200     Y1200     Z1000 E60    ; Start Speed mm/min
M202 X20000    Y15000    Z1500 E4000  ; Max speed mm/min
M203 X1800     Y1800     Z1500 E90    ; Avg speed mm/min
M206 X15000    Y5000     Z1000 E250   ; Acceleration mm/s^2
;M220 X-52.5    Y-58.5    Z1.50        ; Home - min
;M221                     Z117.2       ; Home - max
; LCD setup as per sjfw page on reprap wiki.
M250 P47     ;set LCD RS pin
M251 P43     ;set LCD RW pin
M252 P41     ;set LCD E pin
M253 S4 P39  ;set LCD Data 4 pin
M253 S5 P37  ;set LCD Data 5 pin
M253 S6 P35  ;set LCD Data 6 pin
M253 S7 P33  ;set LCD Data 7 pin - always set last of all LCD pins OR ELSE!
M255 S2 P48  ;set Keypad Col 3 pin
M255 S1 P46  ;set Keypad Col 2 pin
M254 S3 P42  ;set Keypad Row 4 pin
M254 S2 P40  ;set Keypad Row 3 pin
M254 S1 P38  ;set Keypad Row 2 pin
M254 S0 P36  ;set Keypad Row 1 pin
M255 S3 P34  ;set Keypad Col 4 pin
M255 S0 P44  ;set Keypad Col 1 pin - always set last of all Keypad pins OR ELSE!
M104 S0                          ; Turn off hotend heat (Important with EC!)
M140 S0                          ; Turn off platform heat (Important with EC!)
M350 P1                          ; Enable lookahead
;M211 P5000                       ; Report temperatures every 5 seconds
M84                              ; Disable all Motors
M400                             ; End EEPROM write

    I haven’t connected an LCD or keyboard to the thing; for me, printing is fire-and-forget.

  • Rant: Software Testing

    I admit to having expectations, perhaps unreasonable expectations, about what should transpire after filing a bug report with a software project large enough to have a bug tracking system.

    • Acknowledge the report right away, lest it appear nobody cares.
    • Figure out what else you need to know; I give good bug report, but if you need more, ask now.
    • Triage, set, and meet a due date, lest your development process appear shambolic.
    • When we outsiders become the software testers, keep us in the loop.

    My experience shows that the larger and better-funded the organization, the less productive will be any given report: individual problems get lost in the noise. Firefox, Ubuntu, and the late OpenOffice serve as cautionary tales; their forums may help, but submitting a problem report doesn’t increase the likelihood of getting a timely fix.

    I cut one-horse open-source operations considerable slack, although they rarely need any. For example, a recent OpenSCAD problem produced turnaround time measured in hours, including a completely new source file cooked up by a bystander and the lead developer polishing it off a sleep cycle later. That was on Christmas Eve, from on vacation, in a low-bandwidth zone, evidently through an iDingus.

    Perhaps I’m more sensitive to software quality assurance than most folks, but for good reason.

    Quite some years ago, my esteemed wife earned an IBM Outstanding Technical Achievement Award for testing a major component of a major OS. They don’t hand those tchotchkes out lightly and rarely for anything other than development. She had skip-leveled(*) to her umpteenth-level manager: “IBM must not ship this product. It does not work. It is an embarrassment. I will not concur with any decision to ship.”

    The thing eventually shipped, half a year behind schedule, after the developers produced code that passed her test suite and she signed off on the results. Word has it that blood ran ankle-deep in the corridors toward the end.

    If you should ever encounter someone in need of a software-testing team leader who doesn’t take crap from anybody, let me know. She’ll definitely require considerable inducement to drag her back into the field, away from her gardens and quilting…

    So, anyway, we know a bit about software testing and verification and QC in these parts.

    Selah.

    (*) Old-school IBM jargon for walking around several levels of obstructive management to meet with a Big Shot in the corner office. Might not happen in the New IBM, alas.

  • Thing-O-Matic: Software Shuffling

    Having installed the 0.4 mm nozzle, being desirous of turning on Skeinforge’s Dimension plugin, and being therefore faced with recalibrating everything, I figured I might as well update all the software to the current versions before commencing. While this adventure turned out well in the end, it required fitting together a large number of moving parts; this is an overview / core dump of how I picked the pieces.

    Note: I’ve certainly gotten something wrong in this mess, perhaps drastically so. Let me know, but consider the entire assembly before suggesting a different part.

    ReplicatorG is the default Thing-O-Matic printer interface and consists of two parts: the Java-based Arduino-IDE-oid program on the PC and the firmware inside the printer (which is, itself, in two parts divided: Motherboard and Extruder Controller). Their mutual interfaces have become sufficiently tangled that they must upgrade in lockstep, as no versions have backwards or forwards compatibility.

    RepG 29 bundles Skeinforge 35 as its default STL-to-G-Code converter, with 40 and 41 as experimental (i.e., largely unsupported) options. Skeinforge 35 is now ten full clicks behind the current version, came out on 6 November 2010, and has a number of fairly well-known problems. Although I understand the need for upstream stability, SF35 long ago fell off the thick edge of the wedge and even SF41 is 8 months old.

    I have been using RepG with SF40 for much of the last year, having figured out the parameters essentially from scratch to suit my admittedly oddball configuration & preferences. Regressing to SF35 lacks appeal and, frankly, going just one click up to slightly less obsolescent SF41 isn’t in the cards, either. I have no particular aversion to using bone-stock Skeinforge, fetching the most current version as needed, and controlling the update process myself.

    RepG manages Skeinforge profiles that collect its myriad parameters into named groups that can be selected for a particular build. RepG also includes a Print-O-Matic function that pre-sets / computes key SF parameters based on desired extrusion parameters within a given profile, but (apparently) only for SF35. Given that I want a single printer configuration that produces known-good results, putzing around with multiple profiles isn’t of interest and I’m unwilling to use an obsolete version of Skeinforge to sidestep them.

    FWIW, I eventually figured out that having one master set of start.gcode, end.gcode, and alterations.csv files with symlinks from the profiles helps keeps the clutter under control, which is particularly important given the complexity of my homing routine. RepG doesn’t create symlinks in new profiles, but after you’re used to it, you just create a profile, blow away the copies, and install the symlinks.

    So RepG really doesn’t provide what the B-school gurus called a compelling value proposition for my use case. The STL models I cook up using OpenSCAD emerge properly scaled, properly located, properly oriented, and ready to build. All I need is a way to convert those STL models to G-Code, then send G-Code to the printer. Everything else RepG does simply gets in the way.

    The dealbreaker, however, was having RepG 28 occasionally freeze up solid, to the extent of requiring a killall java in a console window to dispose of the corpse. RepG 29 misbehaved the same way and both failed on two different machines with two different versions of Ubuntu. The hole may have been in my end of the boat, but I didn’t devote much time to diagnosing / reporting the problem, given the attention given to the last batch of tickets I opened.

    Freed from the confines of RepG, Skeinforge turns out to be not nearly so intimidating as one might be led to believe. Admittedly, a bit of option pruning helps, but after that you’re left with knobs controlling those things that need controlling.

    Slic3r seems to be the up-and-coming alternative G-Code generator. The key problem, at least for the objects I create, is the lack of an equivalent to the Skeinforge Cool setting that enforces a minimum time for each layer. Printing exactly one of those caliper repair parts at 15 seconds per layer worked perfectly: no fans, no slumping, no hysteria. One could, I suppose, slow the motion throughout the entire object to make the top come out right, but that’s not appropriate for large parts with small towers. Slic3r is under heavy development, so who knows what the New Year will bring?

    Incidentally, my experience with those earlier caliper parts explains why I’m unwilling to regress Skeinforge just to use RepG.

    Kliment’s Printrun wins, hands down, as the RepRap UI that does what I need and very little else. The pronterface GUI presents a reasonably clean, single window printer interface. Even better, from my perspective, is the pronsole command-line interface; I generally do everything except actually print while sitting upstairs in the Comfy Chair, so being able to drive the printer with a command-line interface through a simple SSH session (shared keys, an oddball port, no root logins) is wonderful.

    The pronterface G-Code preview pane has its origin at the lower-left corner, presumably from its RepRap lineage, while RepG puts (0,0) at the build platform’s dead center. Centering the origin avoids baking the platform dimensions into the G-Code and greatly simplifies the overall alignment, but the mismatch is not insuperable: I can ignore the preview and the printer will be perfectly happy.

    However, MBI firmware expects to receive a binary version of the G-Code file, known as S3G and documented there, from the PC through the UI. As nearly as I can tell, nobody else does it that way and none of the other UIs do S3G translation / compilation. Not using RepG means ditching the MBI firmware inside the printer in order to use any other UI.

    The current state-of-the-art open-source 3D printing firmware seems to be the Marlin branch of the Sprinter family tree. Its main appeal, at least for me, is motion control with acceleration limiting, which should resolve most of the problems with the MBI stock firmware and greatly enhance the printer’s performance & print quality. For more details on that topic, search herein for acceleration. Alas, Marlin runs on “single processor electronics” controllers, categorically excluding MBI’s Motherboard + Extruder Controller configuration.

    While I could junk the entire contents of the Thing-O-Matic’s electronics bay and pop in a RepRap RAMPS 1.4,  Generation 6, or Generation 7 electronics package just to use Marlin, that bears a strong resemblance to bad craziness, even by my relaxed standards (although, should another MBI stepper driver board go toes-up, it’ll make considerable economic sense). That comparison of various electronics packages may be helpful. The temperature sense hardware for most of those boards uses thermistors, which means tearing apart the Thermal Core to replace a thermocouple that delivers perfectly accurate results with a thermistor requiring fiddly calibration, which I’d be willing to do, but …

    As it turns out, ScribbleJ’s SJFW firmware runs on both RepRap and MBI electronics, includes acceleration limiting, features automagic endstop position settings for both min & max positions, and seems reasonably stable. It has some quirks (no G0 rapid motion, no G28 homing, weird G-Code parsing assumptions / failures), but on the whole it does what’s needed.

    So the software stack, from the top down, consists of:

    • OpenSCAD
    • Skeinforge
    • Printrun UI — pronsole / pronterface
    • SJFW Motherboard firmware
    • Bone-stock MBI Extruder Controller firmware

    Everything requires configuration / tweaking before plastic starts oozing out of the nozzle. Then I can begin retuning the printing process.

    The overall workflow looks like this:

    • Edit/save OpenSCAD program in external editor on right-hand portrait monitor
    • Watch/examine OpenSCAD 3D rendering on left-hand landscape monitor, iterate
    • Export to STL on file server
    • Convert to G-Code using Skeinforge on PC at printer via SSH
    • Examine proposed G-Code paths with Skeinlayer (set to auto-display), iterate
    • Load/print with pronsole / pronterface via SSH/VNC
    • Trot downstairs to watch the show

    For the relatively simple models I build, CPU load generally isn’t a big deal. I’ll move the Skeinforge config from ~/.skeinforge to the server and add symlinks to it from both PCs, so as to run SF from either PC with the same settings and eliminate synchronization hassles.

    I’ll be writing up my scattered notes over the next week or so…

  • Skeinforge: Simplified Plugin Selection Page

    The Skeinforge Craft window presents a formidable array of buttons, one for each possible plugin:

    Skeinforge standard
    Skeinforge standard

    I’ve disabled many of those plugins because, for example, limiting Z-axis speed isn’t relevant on my printer. If you’re sure you won’t use some of the plugins, remove them by editing /where-it's-installed/skeinforge_application/skeinforge_plugins/profile_plugins/extrusion.py thusly…

    In getCraftSequence(), located at about the midpoint of that file, duplicate the line that lists the plugins and add an octothorpe (OK, a hash) to make one line a Python comment, then remove the plugins you don’t care about from the other line:

    def getCraftSequence():
	'Get the extrusion craft sequence.'
#	return 'carve scale bottom preface widen inset fill multiply speed temperature raft skirt chamber tower jitter clip smooth stretch skin comb cool hop wipe oozebane splodge home lash fillet limit unpause dimension alteration export'.split()
	return 'carve scale preface inset fill multiply speed temperature raft skirt jitter clip smooth skin cool dimension alteration export'.split()

    This being Python, do not change the indentation. If you get overenthusiastic and toss something useful overboard or just pine for the Good Old Days, swap the octothorpe to your modified line to restore the original plugin assortment.

    Save the result and you’ll see only the useful buttons:

    Skeinforge simplified
    Skeinforge simplified

    There, now, wasn’t that easy?

  • HP8591 Spectrum Analyzer Screen Dump Sizes

    The script I use to fetch screen dumps from my HP8591 spectrum analyzer works fine, but it turns out that the screen images have (at least) two sizes.

    The hp2xx program converts the screen dumps from HP-GL text files to PNG bitmaps:

    for f in *hgl ; do hp2xx -m png -c 1436 "$f" ; done

    The usual size is 593x414 pixels:

    SMD 470 pF - Comm Spec
    SMD 470 pF – Comm Spec

    The other size is 593x395 pixels:

    SMD 470 pF - Surplus
    SMD 470 pF – Surplus

    As nearly as I can tell, the spectrum analyzer mashes the Y coordinate when any of the soft keys along the right edge have reverse-video highlights, which print as outlined boxes. There may be other sizes; those are the two I’ve stumbled over so far. This doesn’t much matter unless I’m using the images in a column, in which case it’s awkward to have two sizes: a one-size-fits-all script to trim off the soft keys doesn’t produce the proper results.

    Musing on how to figure this programmatically…

    The file command gives the pixel dimensions, with the file name (which may contain blanks: so sue me) set off  with a colon:

    file "SMD 470 pF - Surplus.png"
SMD 470 pF - Surplus.png: PNG image, 593 x 395, 8-bit colormap, non-interlaced

    Judicious application of cut extracts the relevant numbers, albeit with a trailing comma that requires another pass through the grinder:

    file "SMD 470 pF - Surplus.png" | cut -d\: -f2 | cut -d\  -f4,6
593 395,

    Although I think a sed script might be better, that requires more skull sweat than I have available right now.

    Given that, then an appropriate mogrify would crop off the softkey labels; the first one is what’s in the script right now:

    mogrify -crop "540x414+0+0" SMD\ 470\ pF\ -\ Comm\ Spec.png
mogrify -crop "515x395+0+0" SMD\ 470\ pF\ -\ Surplus.png

    Which looks like this:

    SMD 470 pF - Comm Spec cropped
    SMD 470 pF – Comm Spec cropped

    The two sizes come out pretty close to the same 1.3 aspect ratio, but resizing the smaller one to match the larger doesn’t work well:

    convert -resize '540x414+0+0!' SMD\ 470\ pF\ -\ Surplus.png SMD\ 470\ pF\ -\ Surplus\ resized.png

    You need single quotes around the geometry parameter to prevent Bash (or Dash or whatever) from gnawing on the bang character (yes, that’s how you pronounce “!”).

    The images are lossless PNGs because they consist entirely of single-pixel lines and characters; alas, resizing by non-integer factors close to 1.0 introduces nasty picket-fence aliasing artifacts:

    Resize x 1.049
    Resize x 1.049

    I resize the pix by a nice, even factor of two (which also adds aliasing artifacts, but in small and very regular doses) and set the dots/inch value so the images print at about the right size without further hassle along the production pipeline:

    mogrify -density 300 -resize 200% whatever.png

    Which looks like this:

    Resize 2.00
    Resize 2.00

    Resizing from the smaller images to (roughly) the final size in one step doesn’t look quite so awful:

    convert -density 300 -resize 209% "SMD 470 pF - Surplus.png" "SMD 470 pF - Surplus large.png"

    Like this, still with a distinctly garbled dBm:

    Resize 2.09
    Resize 2.09

    But it’s decidedly better than this result from a two-step enlargement, although not as wonderful as one might like:

    Resize x 1.049 x 2.00
    Resize x 1.049 x 2.00

    So the script needs a tweak for the file sizes, but …

    Memo to Self: It’d be simpler to not have highlighted softkeys when doing screen dumps!

  • Enabling Remote Desktop Sharing in Xubuntu

    I set up Xubuntu 11.10 on the Dell 531S driving the Thing-O-Matic, as the Unity UI seems surprisingly like crippleware: every feature that isn’t mandatory is prohibited. However, Xubuntu’s XFCE UI also has a long list of things that should be easy and aren’t, such as enabling remote desktop sharing. Gotta have that so I can fire up the printer and monitor progress from upstairs.

    It turns out that the Vino server is installed, but not enabled, so you must start by firing up vino-preferences in a terminal to set some preferences:

    This is a local machine behind a firewall, so a moderately secure password with no confirmation will suffice. Your paranoia may vary.

    Then drill down through the menu from Settings → Settings Manager → Session and Startup to the Application Autostart tab, then Add the Vino VNC Server to the list: /usr/lib/vino/vino-server. You can start it manually if you have the hots for immediate sharing.

    This seems to be impossible in Unity, trivially easy in GNOME, and unduly mysterious in XFCE.

  • Thing-O-Matic: Large Hole Calibration

    Flushed with success on the small-hole front, I conjured up a large hole testpiece using the same HoleAdjust function that proved unnecessary with the little ones:

    Circle Calibration - solid model
    Circle Calibration – solid model

    The first version didn’t have the cross bars, which turned out to be a mistake, because the individual rings distorted even under minimal pressure from the calipers:

    Large circle cal - unlinked rings
    Large circle cal – unlinked rings

    However, measuring as delicately as I could, the holes seemed a scant 0.20 mm too small, more or less, kinda-sorta:

    Nominal Nom+0.0
    10 9.83
    20 19.75
    30 29.85
    40 39.84
    50 49.84
    60 59.72
    70 64.76
    80 79.28
    90 89.77

    So I fed in HoleFinagle = 0.20 and the second iteration looks like it’d make a great, albeit leaky, coaster:

    Large Circle Calibration object - HoleFinagle 0.20
    Large Circle Calibration object – HoleFinagle 0.20

    Measuring those holes across the center with the calipers on facets (rather than vertices), produced somewhat more stable results:

    Nominal Nom+0.20
    10 10.08
    20 20.17
    30 30.08
    40 40.08
    50 50.00
    60 60.02
    70 70.05
    80 79.98
    90 90.07

    Frankly, I don’t believe those two least-significant digits, either, because a different set of measurements across different facets looked like this:

    Nominal Nom+0.20
    10 10.13
    20 20.11
    30 29.84
    40 39.90
    50 49.88
    60 59.90
    70 69.84
    80 79.82
    90 89.66

    I also printed a testpiece with HoleFinagle = 0.25 that averaged, by in-the-head computation, about 0.05 larger than that, so the hole diameter compensation does exactly what it should.

    Applying the calipers to the 10.0 mm hole in the small-hole testpiece gives about the same result as in this one. The fact that HoleFinagle is different poses a bit of a mystery…

    The only thing I can conclude is that the measurement variation and the printing variation match up pretty closely: the actual diameter depends more on where it’s measured than anything else. The holes are pretty nearly the intended size and, should the exact size matter, you (well, I) must print at least one to throw away.

    All in all, a tenth of a millimeter is Good Enough. Selah.

    Oh. The ODs are marginally too small, even using PolyCyl.

    The OpenSCAD source, with both adjustments set to neutral:

    // Large circle diameter calibration
// Ed Nisley KE4ZNU - Nov 2011

//-------
//- Extrusion parameters must match reality!
//  Print with +1 shells, 3 solid layers, 0.2 infill

ThreadThick = 0.33;
ThreadWidth = 2.0 * ThreadThick;

HoleFinagle = 0.00;
HoleFudge = 1.00;

function HoleAdjust(Diameter) = HoleFudge*Diameter + HoleFinagle;

Protrusion = 0.1;			// make holes end cleanly

function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit);

//-------
// Dimensions

Width = 2.5;
Thickness = IntegerMultiple(2.0,ThreadThick);

DiaStep = 10.0;

NumCircles = 9;

echo(str("Width: ",Width));
echo(str("Thickness: ",Thickness));

BarLength = (NumCircles + 1)*DiaStep;

//-------

module PolyCyl(Dia,Height,ForceSides=0) {			// based on nophead's polyholes

  Sides = (ForceSides != 0) ? ForceSides : (ceil(Dia) + 2);

  FixDia = Dia / cos(180/Sides);

  cylinder(r=HoleAdjust(FixDia)/2,h=Height,$fn=Sides);
}

module ShowPegGrid(Space = 10.0,Size = 1.0) {

  Range = floor(50 / Space);

	for (x=[-Range:Range])
	  for (y=[-Range:Range])
		translate([x*Space,y*Space,Size/2])
		  %cube(Size,center=true);

}

//------

module Ring(RingID,Width,Thick) {

  difference() {
	PolyCyl((RingID + 2*Width),Thick);
	translate([0,0,-Protrusion])
	  PolyCyl(RingID,(Thick + 2*Protrusion));
  }
}

//------

ShowPegGrid();

union () {
  for (Index = [1:NumCircles])
	Ring(Index*DiaStep,Width,Thickness);
  for (Index = [-1,1])
	rotate(Index*45)
	  translate([-BarLength/2,-Width/2,0])
		cube([BarLength,Width,Thickness]);
}