Posts Tagged CNC

HP 7475A Plotter: Roland Knife Holder-Stabilizer

Somewhat encouraged by the results of the height-map cap atop the plotter’s pen holder, I figured a unified knife adapter and stabilizer cap would work even better. That requires enough accuracy to build a real solid model, rather than just sketch a height map…

Print out the the grid-overlaid image of the pen holder, then doodle coordinates & measurements all over the poor thing:

HP 7475A Pen Holder - gridded doodle

HP 7475A Pen Holder – gridded doodle

Now I can toss that piece of paper…

That, plus a bit of digital caliper work, produces a flurry of dimensions & an array of vertices:

//-- Plotter pen holder stabilizer

HolderPlateThick = 3.0;				// thickness of plate atop holder
RimHeight = 5.0;					// rim around sides of holder
RimThick = 2.0;

HolderOrigin = [17.0,12.2,0.0];		// center of pen relative to polygon coordinates

HolderZOffset = 30.0;				// top of holder in pen-down position
HolderTopThick = 1.7;				// top of holder to top of pen flange
HolderCylinderLength = 17.0;		// length of pen support structure

HolderKnifeOffset = -2.0;			// additional downward adjustment range (not below top surface)

LockScrewInset = 3.0;				// from right edge of holder plate
LockScrewOD = 2.0;					// tap for 2.5 mm screw

// Beware: update hardcoded subscripts in Stabilizer() when adding / deleting point entries 

HolderPlate = [
	[8.6,18.2],[8.6,23.9],			// 0 lower left corner of pen recess
	[13.9,23.9],[13.9,30.0],		// 2
//	[15.5,30.0],[15.5,25.0],		// 4 omit middle of support beam
//	[20.4,25.0],[20.4,30.0],		// 6
	[22.7,30.0],[22.7,27.5],		// 4
	[35.8,27.5],[35.8,20.7],		// 6 spring box corner
	[43.0,20.7],					// 8
	[31.5,0.0],						// 9
//	[24.5,0.0],[24.5,8.0],			// 10 omit pocket above pen clamp
//	[22.5,10.0],[22.5,16.5],		// 12
//	[20.5,18.2]						// 14
	[13.6,0.0],						// 10
	[8.6,5.0]						// 11
	];

BeamWidth = HolderPlate[4][0] - HolderPlate[2][0];

The general idea is to extrude the overall shape of the stabilizer cap, carve out chunks to fit it onto the pen holder, then add a cylinder around the knife bearing:

HP7475A - Roland knife stabilizer - bottom - thrown together view

HP7475A – Roland knife stabilizer – bottom – thrown together view

The OpenSCAD source code contains a bunch of magic numbers and indexes that pull values from the vertex array:

module Stabilizer(SeeKnife = false) {

  difference() {
    union() {
      translate(-HolderOrigin)                                            // put center of pen at origin
        difference() {
            render(convexity=4)
            linear_extrude(height=(HolderPlateThick + RimHeight))         // overall flange around edges
              offset(r=RimThick)
                  polygon(points=HolderPlate);

            render(convexity=4)
            translate([0,0,-Protrusion])                                  // recess for pen holder plate
              linear_extrude(height=(RimHeight + Protrusion))
                polygon(points=HolderPlate);

            translate([HolderPlate[7][0] - Protrusion,HolderPlate[7][1] - Protrusion,-Protrusion])  // trim spring box from top plate
              cube([30,20,(RimHeight + HolderPlateThick + 2*Protrusion)]);

            translate([27.0,HolderPlate[6][1] - Protrusion,-Protrusion])  // trim pivot plate clearance
              cube([30,20,(RimHeight + HolderPlateThick + 2*Protrusion)]);

            translate([HolderPlate[2][0],20,-Protrusion])                 // trim left support beam
              cube([BeamWidth,20,(RimHeight + Protrusion)]);

            translate([HolderPlate[9][0] - LockScrewInset,RimThick,RimHeight - HolderTopThick - LockScrewOD/2])                        // lock screw on front edge
              rotate([90,0,0])
                rotate(180/4)
                  PolyCyl(LockScrewOD,3*RimThick);                        // hold-down screw hole
        }

      translate([0,0,(RimHeight - HolderCylinderLength + Protrusion)])
        cylinder(d=BodyOD,h=HolderCylinderLength + Protrusion,$fn=NumSides);  // surround knife threads
    }

    translate([0,0,-HolderZOffset + HolderKnifeOffset])
      if (SeeKnife)
#        Knife();
      else
        Knife();
  }
}

A bottom view shows all the cutouts:

HP7475A - Roland knife stabilizer - build layout

HP7475A – Roland knife stabilizer – build layout

The little hole in the front fits a screw that will pass under the top plate of the pen holder and prevent the cutting forces from pushing it off.

As with the Sakura pen adapter, the knife point sits at (0,0,0) with the stabilizer cap positioned at the (estimated) top of the pen holder:

Roland knife stabilizer - show layout

Roland knife stabilizer – show layout

After a few print-and-try iterations to align all the fiddly cutouts:

HP 7475A - Roland knife stabilizer - installed

HP 7475A – Roland knife stabilizer – installed

The slope-topped block protruding toward you from the bottom right actuates the carousel’s pen capping mechanism; it doesn’t quite touch the side of an HP pen and is well clear of the knife holder.

Because there’s still no depth control surrounding the knife blade, this won’t work well at all, but it should suffice for better measurements.

The full source code is back at the beginning.

, ,

Leave a comment

HP 7475A Plotter: Pen Holder Height Map Cap

The “pen holder” in an HP 7475A plotter carries the pen across the width of the paper:

HP 7475A - Pen Holder - overview

HP 7475A – Pen Holder – overview

Given that it was designed to carry pens, not knives, I wasn’t surprised that the spring-loaded finger clamping the knife adapter didn’t apply enough force to hold the adapter in place against the cutting forces. I figured a quick test of a gizmo to stabilize the adapter would be in order, even though I knew:

  • The pen holder doesn’t apply enough downward force
  • The knife adapter doesn’t have a depth-of-cut shroud around the blade

In order to build the gizmo, I need the carrier’s dimensions…

An overhead photo of the pen holder shows the layout in the XY plane:

HP7475A - pen holder - top view

HP7475A – pen holder – top view

I shouldn’t have used graph paper as a background, because the next step was to remove the background and isolate the carrier:

HP7475A - pen holder - top view - isolated

HP7475A – pen holder – top view – isolated

The carrier measures 26.8 mm front-to-back, so scaling a grid to match that dimension provides a coordinate system overlay:

HP7475A - pen holder - top view - 1 mm grid

HP7475A – pen holder – top view – 1 mm grid

The (0,0) origin sits at the lower left, so you can read off all the relevant coordinates as needed.

However, rather than go full-frontal digital, I resized the isolated image to 20 pixel/mm, turned it into a height map, and treated it like a chocolate mold or cookie cutter with gray values scaled to the desired height:

  • Black = background to be removed
  • Dark gray = 2.5 mm thick
  • Medium gray = 3.5 mm
  • Light gray = 7 mm
  • White = 10 mm

Drawing the walls with a 40 pixel diameter pen makes them 2 mm wide at 20 pixel/mm:

HP7475A - knife stabilizer

HP7475A – knife stabilizer

It’s painfully obvious why I don’t do much freehand drawing, although the knife adapter hole is supposed to be oval.

As with cookie cutters and chocolate molds, there’s no need for that much resolution, so I rescaled it to 4 pixel/mm, saved that tiny image as a PNG file, and handed it to OpenSCAD’s surface() function to get a solid model. This being a one-off, I typed this OpenSCAD source code directly into the OpenSCAD editor on the fly, then remembered to save it (!) before shutting down:

rotate([0,180,0])
mirror([0,0,1])
scale([0.25,0.25,10/100])
difference() {
  translate([0,0,-2.0]) render(convexity=10)
    surface("/long-and-tedious-path/HP7475A - knife stabilizer - scaled.png",center=true);
  translate([0,0,-200])
    cube(400,center=true);
}

The mirror() transformation inverts the model top-to-bottom along the Z axis, compensating for the flip from drawing the height map as though the walls rise upward from the pen carrier, after which the flip() transformation puts the flat side down to make it buildable.

The height map image conversion produces a bazillion irrelevant faces, but it’s quick and easy:

HP7475A - Roland knife stabilizer - height map model

HP7475A – Roland knife stabilizer – height map model

I’ve been using Slic3r’s Hilbert Curve  pattern for top & bottom infill to get a nice textured result:

Roland knife stabilizer - height map - Slic3r preview

Roland knife stabilizer – height map – Slic3r preview

Which printed just about like you’d expect:

HP 7475A - Roland knife adapter and stabilizer - height map - bottom view

HP 7475A – Roland knife adapter and stabilizer – height map – bottom view

I reamed out the hole with a step drill (the HP pens are close enough to 7/16 as to make no difference here) to get the knife adapter to fit, but the walls and suchlike came out close enough.

Then it just snapped into place:

HP 7475A - Roland knife adapter and stabilizer - height map

HP 7475A – Roland knife adapter and stabilizer – height map

Actually, no, it didn’t just snap into place: some (dis)assembly was required.

First, remove the brass knife bearing from the adapter, push the knife adapter shell into the pen holder, slide the stabilizer cap down over the adapter, press it firmly around the pen holder, reinstall the brass knife bearing, then it’s ready.

The cuts in the green vinyl just to the left of the knife blade (in a window decoration sheet I spotted in a trash can) show that the blade can cut, albeit with some finger pressure, but the fancy red stabilizer didn’t stay stuck on the pen carrier nearly as well as I expected. A screw attachment will help with that, which calls for going all digital on those coordinates.

But it was quick & easy…

,

6 Comments

HP 7475A Plotter: Roland Knife Adapter

Knockoff Roland drag knife blades and holders being cheap and readily available on eBay, it didn’t take long to figure out that they’re not drop-in replacements for HP pens:

HP 7475A - Roland knife holder vs HP pen

HP 7475A – Roland knife holder vs HP pen

The Roland Cutter Knowledge PDF shows that the blade must protrude just slightly beyond the holder shell, letting the flat end stabilize the media and regulate the cut depth, but some experimentation was in order just to get the mechanics worked out.

The central brass blade holder looks like it should fit neatly inside the pen body outline:

HP 7475A - Roland knife holder - internal

HP 7475A – Roland knife holder – internal

A small O-ring normally fits in the thread gap to provide some friction between the two metal parts, with the knurled nut locking them together at the desired setting.

The blade rides on a smooth bearing pushed upward against a stop by a spring exerting 220-400 g on that rounded shaft. I think a real vinyl cutter would have a spring-loaded pin pushing downward on that shaft to provide vertical compliance at the blade tip, but I’ve never seen such a thing in real life.

That suggests half a pound of downward cutter force that the HP pen holder definitely can’t provide; the spec is 19±10 g.

Applying a digital caliper to the blade holder produced the usual measurement array:

//-- Drag knife holder

ExpRK = 0.30;						// expand critical sections (by radius)
AdjLen = 2.0;						// allowance for adjustment travel

KnifeOutline = [
	[0,0],							//  0 blade point (actually 0.25 mm offset)
	[1.0/2,0.0],					//  1  ... blunt end
	[1.0/2,4.0],					//  2  ... cylinder
	[2.0/2,4.0],					//  3 shank
	[2.0/2,5.9],					//  4  .. at bearing
	[6.0/2,5.9],					//  5 holder - shell
	[7.3/2 + ExpRK,8.3],			//  6 holder - taper to body
	[7.3/2 + ExpRK,21.0 - AdjLen],	//  7 holder body
	[8.8/2 + ExpRK,22.0 - AdjLen],	//  8 holder - threads bottom
	[8.8/2 + ExpRK,25.0],[9.0/2 + ExpRK,26.0],		//  9 clear threads to reduce friction
	[9.0/2 + ExpRK,32.0],[8.8/2 + ExpRK,33.0],		// 11  ... end clearance
	[8.8/2 + ExpRK,42.5 - AdjLen],	// 13 holder - threads top = locknut bottom
	[12.5/2,42.5 - AdjLen],			// 14 knurled locknut - adjustment travel
	[12.5/2,45.8],					// 15 knurled locknut - top
	[11.0/2,45.8],					// 16 holder - adjusting knurl
	[11.0/2,52.0],					// 17 holder - top surface
	[3.0/2,52.0],[3.0/2,57.2],		// 18 spring post
	[0.0,57.2]						// 19 end of post
	];

ThreadLength = KnifeOutline[13][HEIGHT] - KnifeOutline[8][HEIGHT];

Which spins up into a solid model of the brass part:

HP7475A - Roland knife holder - solid model

HP7475A – Roland knife holder – solid model

The large ring is slightly larger than the actual knurled nut, to ensure it cuts off the top of the HP pen body.

The raised section in the middle of the threads provides a little relief, as screwing the holder into a sufficiently snug plastic sleeve turned out to require more effort than seemed reasonable. I don’t have a tap for what might be a loose 9×0.75 mm fine-pitch thread (the actual OD is 8.75), so it’s gotta form its own path.

Subtracting the holder from the HP pen body produced an adapter much like the Sakura pen adapters:

HP7475A - Roland knife adapter - solid model

HP7475A – Roland knife adapter – solid model

Split across the flange for building:

HP7475A - Roland knife adapter - build layout

HP7475A – Roland knife adapter – build layout

Running the plotter in Etch A Sketch mode, that little blade actually cut a sheet of paper:

HP 7475A - Roland knife adapter - first cut

HP 7475A – Roland knife adapter – first cut

However, it didn’t cut very well at all, mostly because the pen holder doesn’t grip the adapter tightly enough to resist the lateral forces required to drive the blade through the paper, nor does it provide enough downward force to maintain the cut; I cheated by pressing on the holder to encourage the blade to keep on cutting.

By design, the plotter pen lift / drop mechanism doesn’t (and really can’t) apply enough downward force. A sliding bar across the entire width of the plotter raises the holder through a mechanical tab and lowers the holder by releasing the tab. A small spring then provides all the downward force, overcoming a dashpot that slows the pen drop to prevent crushing the nib against the paper.

Just for fun, though, I figured I should see what happens with the blade firmly anchored in the pen holder…

, ,

Leave a comment

HP 7475A Plotter: Full-up Sakura Micron Pen Tests

The HP 7475A plotter comes with a transparent smoke-brown plastic flip-up lid covering the carousel and pen holder, presumably to keep dust and fingers out of the moving parts. That lid also has has the side effect of limiting the pen length, presumably because HP didn’t want the 7475A to eat into their large-format plotter market. In any event, removing the lid leaves another barrier to longer pens: the rugged plastic case between the carousel and the pen holder.

Well, seeing as how this puppy has been fully depreciated, a bit of pull saw work opened that opportunity:

HP 7475A - long pen case cut

HP 7475A – long pen case cut

Despite appearances, all six Sakura Micron pens emerge vertical & parallel from their adapters in the carousel:

HP 7475A - Sakura 01 and 005 pens in carousel

HP 7475A – Sakura 01 and 005 pens in carousel

They pass neatly through the new channel:

HP 7475A - cover mod for long pens

HP 7475A – cover mod for long pens

And produce reasonable lines, with motion blur catching the pen holder in the midst of a pen-up / pen-down twitch:

HP7475A - Sakura Micro Pen Adapter - self-test plot

HP7475A – Sakura Micro Pen Adapter – self-test plot

That’s from an earlier test, before I sawed the slot in the case, with all the machinery behind the pen holder in full view.

The test plot, with the proper pen colors and widths loaded in the carousel, looks pretty good:

HP7475A - Sakura Micro Pens - self-test plot

HP7475A – Sakura Micro Pens – self-test plot

The pen holder wasn’t intended to support a long pen, so that shaft tends to torque the pen tip out of position, particularly while drawing characters:

HP 7475A - long black pen - misalignment

HP 7475A – long black pen – misalignment

The various pen tips don’t all point to the same place:

HP 7475A - long RGBK pen misalignment

HP 7475A – long RGBK pen misalignment

That could be non-concentric pen adapters, misalignment in the pen holder, or slightly off-center pen nibs. The offsets between the colors remains consistent in all the bar-chart columns, so the pen adapters aren’t shifting in the holder.

The worst-case error between bar-chart rectangles amounts to 0.5 mm parallel to the pen holder motion and 0.8 mm parallel to the paper motion. In round numbers, the pen tip is 30 mm from the flange, so moving it 0.5 mm to the side tips the pen 1°. The flange is 17 mm OD, which means a 1° tilt raises one edge by 0.3 mm or both edges by ±0.15 mm. Given a 0.25 mm 3D printed thread thickness, that’s certainly within reach of a random plastic blob.

Looking closely at the printed-and-glued flange shows plenty of room for misunderstanding betwixt pen and holder, even after cleaning off all that PETG hair:

HP7475A - Sakura Micro Pen Adapter - vs HP pen

HP7475A – Sakura Micro Pen Adapter – vs HP pen

Given that the Sakura pens aren’t intended for this application, a slight tip misalignment due to body molding tolerances isn’t unreasonable; a perfect adapter might not solve the problem.

The HP maintenance manual lists a BASIC program to produce a test plot that verifies pen alignment, although the prospect of transliterating 2+ pages of quoted strings from a scanned document doesn’t fill me with desire.

, ,

7 Comments

Epson S5 Projector Foot Repair

First up: it’s not our projector, which means the usual Rules of Engagement do not apply.

A few small black plastic fragments fell out of the Epson S5 projector’s carry bag, the front foot wouldn’t remain extended, and, as one might expect, the two incidents were related. Mary needed it for the gardening class she was teaching the next evening, sooooo

A pair of plastic snaps release the entire foot assembly from the front of the projector:

Epson S5 Projector Foot - assembled

Epson S5 Projector Foot – assembled

It became obvious that we didn’t have all the fragments, but it was also obvious that, even if we had the pieces, a glued assembly wouldn’t last very long.

The threaded plastic stem surrounds a steel pin that’s visible when you remove the rubber foot pad. That pin holds the latch on the end of the stem outward, so that the stem can’t fall out. Drive out the pin with a (wait for it) pin punch inserted from the foot pad end, which reveals the broken plastic doodad:

 

Epson S5 Projector Foot - stem removed

Epson S5 Projector Foot – stem removed

Release the latches on the gray handle and the intricate half-nut that engages the threaded stem slides out:

Epson S5 Projector Foot - disassembled

Epson S5 Projector Foot – disassembled

A plastic spring in the boxy shell pushes the gray handle and half-nut against the stem, holding the stem in place. Pushing the gray handle upward (on the projector, downward in the picture, yes, your fingertip can feel those ribs just fine) pulls the half-nut away from the stem and lets the stem slide freely. With the stem extended, the projector leans on the stem, pushes it against the half-nut, and you can fine-tune the angle by turning the stem; the splines around the rubber foot encourage that. You can pull the stem outward without activating the latch, which probably broke the fragile plastic plate.

A doodle showing the estimated measurements, plus three 3D printed prototypes required to get a good fit:

Epson S5 Projector Foot - measurements and versions

Epson S5 Projector Foot – measurements and versions

The solid model looks about like you’d expect:

Epson S5 Projector foot latch - solid model

Epson S5 Projector foot latch – solid model

The first version (leftmost of the three sitting on the doodle, above) had angled ends on the tabs that I intended to match up with the stubs remaining on the OEM latch. The part fit better with shorter tabs and the angles vanished on third version; the statements remain in the OpenSCAD source, but the short tabs render them moot.

Apparently I got the cooling & fan & minimum layer time pretty close to right for PETG, as each of those three towers printed singly with no slumping:

Epson S5 Projector Foot - V1 on platform

Epson S5 Projector Foot – V1 on platform

The third version snapped into place, with a square of tapeless sticky on the back to help keep it there. The obligatory Kapton tape helps retain it, but I have no illusions about the permanence of this repair:

Epson S5 Projector Foot - repair installed

Epson S5 Projector Foot – repair installed

Because I know the problem will happen again, I called for backup:

Epson S5 Projector Foot - 5 copies

Epson S5 Projector Foot – 5 copies

That’s with Hilbert Curve top / bottom fill, three top / bottom layers, 20% rectilinear infill, and two perimeters. Extruder at 250 °C, platform at 90 °C, hairspray for adhesion.

Note, however, the hair-fine strings connecting the towers. Retraction must be just about right, as shown by the overall quality of the objects, but PETG comes out really stringy. Choosing an infill pattern to minimize retraction seems like a big win; relatively sparse 3D Honeycomb works well on larger objects, but these were so small that straight line fill fit better. The flat plates on the bottom consist of five completely solid layers of PETG.

Reports from the field indicate complete success: whew!

One could, of course, just buy a replacement from the usual eBay supplier, if one were so inclined.

The OpenSCAD source code:

// Epson S5 projector foot latch repair
// Ed Nisley KE4ZNU - March 2015

Layout = "Build";

//- Extrusion parameters must match reality!

ThreadThick = 0.25;
ThreadWidth = 0.40;

HoleWindage = 0.2;

Protrusion = 0.1;			// make holes end cleanly

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

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

Plate = [16.7,9.0,1.25];

Block = [12.5,2.5,10.0];

HoleDia = 7.7;
HoleRadius = HoleDia/2;

HoleOffset = 3.5 + HoleDia/2;					// +Y edge to hole center
HoleSides = 8;

StubLeft= 9.5;
StubLeftAngle = asin((StubLeft - HoleOffset) / (HoleRadius));

StubRight = 9.1;
StubRightAngle = asin((StubRight - HoleOffset) / (HoleRadius));

//----------------------
// Useful routines

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=(FixDia + HoleWindage)/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 RodSupport() {
	difference() {
		union() {
			translate([0,(HoleOffset-Plate[1]/2),Plate[2]/2])
				cube(Plate,center=true);
			translate([0,HoleOffset-Block[1]/2,-(Block[2] - Protrusion)/2])
				cube(Block + [0,0,Protrusion],center=true);
		}
		translate([0,0,-2*Block[2]])
			rotate(180/HoleSides)
				PolyCyl(HoleDia,4*Block[2],HoleSides);
		rotate(StubLeftAngle)
			translate([-2*HoleDia,-HoleDia,-Protrusion])
			cube([2*HoleDia,HoleDia,Plate[2] + 2*Protrusion],center=false);
		rotate(-StubRightAngle)
			translate([0,-HoleDia,-Protrusion])
				cube([2*HoleDia,HoleDia,Plate[2] + 2*Protrusion],center=false);

	}
}

//----------------------
// Build it

//ShowPegGrid();

if (Layout == "Show")
	RodSupport();

if (Layout == "Build")
	translate([0,0,Plate[2]])
		rotate([0,180,0])
			RodSupport();

, , ,

2 Comments

Calibration Boxes for 3D Printing

The OpenSCAD script now produces either a thinwall open box or a solid box with the same outside shape and dimensions:

The rounded corners prevent edge glitches from throwing off the measurement, plus they verify that small segments print properly.

lengthy writeup on why I like the thinwall open box so much may be more than you want to know on the subject. Just do it, OK?

The solid box lets you check the outside dimensions (20 x 20 x 5 mm) and the slicer’s infill parameters.

The first few attempts with a new setup won’t look very good, but that’s the whole point:

M2 V4 Calibration Objects

M2 V4 Calibration Objects

Getting a workable profile and accurate Z-axis setting required maybe a dozen quick prints & parameter changes. After that, they’re good for verifying that any change you make hasn’t screwed up something beyond recovery.

Put five of them on the platform to verify overall alignment (“leveling”) and first-layer thickness:

Thinwall Calibration Cubes - 5 copies

Thinwall Calibration Cubes – 5 copies

A few iterations will generate plenty of show-n-tell tchotchkes:

Thinwall open boxes from platform leveling

Thinwall open boxes from platform leveling

As nearly as I can tell, if you can’t print these reliably, there’s no point in trying to print anything else.

Even better, when you suddenly can’t print anything else reliably, these simple boxes will tell you what’s gone wrong…

The OpenSCAD source code:

// Calibration boxes
//  Thin wall open box - set Extrusion Multiplier
//  Solid box - verify infill settings
// Ed Nisley - KE4ZNU - 2015-03

Layout = "Open";					// Open Solid

//-------
//- Extrusion parameters must match reality!

ThreadThick = 0.25;
ThreadWidth = 0.40;

Protrusion = 0.1;           // make holes end cleanly

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

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

Height = IntegerMultiple(5.0,ThreadThick);

WallThick = 1*ThreadWidth;

CornerRadius = 2.0;
CornerSides = 4*8;

SideLen = 20.0 - 2*CornerRadius;

Rotation = 45;

//-------

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 Solid() {
	hull() {
		for (i=[-1,1], j=[-1,1])
			translate([i*SideLen/2,j*SideLen/2,0])
				cylinder(r=CornerRadius,h=Height,$fn=CornerSides);
	}
}

module Thinwall() {
	difference() {
		Solid();
		hull() {
			for (i=[-1,1], j=[-1,1])
				translate([i*SideLen/2,j*SideLen/2,-Protrusion])
					cylinder(r=(CornerRadius - WallThick),h=(Height + 2*Protrusion),$fn=CornerSides);
		}
	}
}

//-------

//ShowPegGrid();

rotate(Rotation)
	if (Layout == "Open")
		Thinwall();
	else
		Solid();

, ,

Leave a comment

Monthly Image: Spherometer Measurements

Our Larval Engineer volunteered to convert the lens from a defunct magnifying desk lamp into a hand-held magnifier; there’s more to that story than is relevant here. I bulldozed her into making a solid model of the lens before starting on the hand-holdable design, thus providing a Thing to contemplate while working out the holder details.

That justified excavating a spherometer from the heap to determine the radius of curvature for the lens:

Student Sphereometer on lens

Student Sphereometer on lens

You must know either the average radius / diameter of the pins or the average pin-to-pin distance. We used a quick-and-dirty measurement for the radius, but after things settled down, I used a slightly more rigorous approach. Spotting the pins on carbon paper (!) produced these numbers:

Sphereometer Pin Radii

Sphereometer Pin Radii

The vertical scale has hard-metric divisions: 1 mm on the post and 0.01 on the dial. You’d therefore expect the pins to be a hard metric distance apart, but the 25.28 mm average radius suggests a crappy hard-inch layout. It was, of course, a long-ago surplus find without provenance.

The 43.91 mm average pin-to-pin distance works out to a 50.7 mm bolt circle diameter = 25.35 mm radius, which is kinda-sorta close to the 25.28 mm average radius. I suppose averaging the averages would slightly improve things, but …

The vertical distance for the lens in question was 0.90 mm, at least for our purposes. That’s the sagitta, which sounds cool enough to justify this whole exercise right there. It’s 100 mm in diameter and the ground edge is 2.8 mm thick, although the latter is subject to some debate.

Using the BCD, the chord equation applies:

  • Height m = 0.90 mm
  • Base c = 50.7 mm
  • Lens radius r = (m2 + c2/4) / 2m = 357.46 mm

Using the pin-to-pin distance, the spherometer equation applies:

  • Pin-to-pin a = 43.91 mm
  • Sagitta h = 0.90 mm
  • Lens radius R = (h/2) + (a2 / 6h) = 357.50 mm

Close enough, methinks.

Solving the chord equation for the total height of each convex side above the edge:

  • Base c = 100 mm
  • Lens radius r = 357.5 mm
  • Height m = r – sqrt(r2 -c2/4) = 3.5 mm

So the whole lens should be 2 · 3.5 + 2.8 = 9.8 mm thick. It’s actually 10.15 mm, which says they were probably trying for 10.0 mm and I’m measuring the edge thickness wrong.

She submitted to all this nonsense with good grace and cooked up an OpenSCAD model that prints the “lens” in two halves:

Printed Lens - halves on platform

Printed Lens – halves on platform

Alas, those thin flanges have too little area on the platform to resist the contraction of the plastic above, so they didn’t fit together very well at all:

Printed Lens - base distortion

Printed Lens – base distortion

We figured a large brim would solve that problem, but then it was time for her to return to the hot, fast core of college life…

,

Leave a comment