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: Recumbent Bicycling

Cruisin’ the streets

Presta Valve: Proper Pump Attachment Thereto

All our bikes have Presta valves, which seem better suited for bike rims than the larger and more common automotive Schraeder valves:

Presta valve stem

For all these years, I’d been attaching the pump head so the obvious sealing ring near the nozzle opening lined up with the flat section adjacent to the valve core stem. The pump head never seemed stable on the stem, often leaked, and generally had a precarious hold:

Incorrect Presta pump head attachment

Come to find out, more by accident than intention, that the correct way to attach the pump head involves ramming it all the way down onto the stem so that it can seal along the entire length of the threads. That’s nice and secure, doesn’t leak, and even looks like it should work perfectly:

Correct Presta pump head attachment

I’d feel even more like a doof if I hadn’t learned to do it wrong by watching somebody else back in the day or if I haven’t observed many other people making exactly the same mistake. I think the fact that the short nozzles on the old-school Zéfal pumps I swore by back in my wedgie-bike days never got a good grip on Presta stems got me off to a bad start, but … dang do I feel stupid.

FWIW, the little tab sticking out under the latch handle makes up for a bit of slop in the valve head. When I got the pump, the Schraeder nozzle didn’t seal very well, either, and taking up a few mils of slack helped immeasurably. We don’t need that nozzle very often, but our bicycle touring guests frequently do; they know that they can top off a Schraeder-valved tube at any gas station or with any pump anywhere around the world.

[Update: I hate it when I misspell a word in the title…]

2011-11-23
Self-resonant Frequencies of Some Ceramic Capacitors
In that version of the GPS+voice interface, I sprinkled 100 nF and 100 pF SMD caps across the input lines in the hope that they’d reduce EMI on the audio board. The board worked fine for years, but now that it’s time to build another board & box, I figured it’d be good to know a bit more about their actual response.

So I cobbled up a test fixture with a 3 dB pad from the tracking generator output and a 20 dB pad to the spectrum analyzer input (both of those are bogus, because the cap impedance varies wildly, but work with me on this):

Ceramic 100 nF cap on copper

Pulled an assortment of 100 nF ceramic caps from the stockpile:

100 nF ceramic capacitor assortment

And rubbed them against the HP8591 spectrum analyzer & tracking generator:

Cap Comparison – Detail

Their self-resonant frequencies are much lower than I expected:

Cap Comparison

The attenuators produce about 17 dB of loss with no cap in the circuit, so the disk caps are pretty much asleep at the switch from VHF on up. The small bypass cap in the top photo is OK and the SMD cap is pretty good, but they’re all well past their self-resonant frequency and acting like inductors.

The relevant equations:
- F_R = 1/(2π √(LC))
- X_C = 1/(2π f C)
- Q = F_R / BW
- ESR = X_C / Q
The drill goes a little something like this:
- Find resonant frequency F_R and 3 db bandwidth BW
- Knowing F_R and C, find parasitic L
- Knowing F_R and BW, find Q
- Knowing X_C and Q, find ESR
In round numbers, the 100 nF SMD cap has L=2 nH and ESR=60 mΩ.

Now, it turns out a 100 pF SMD cap resonates up at 300 MHz, between the VHF and UHF amateur bands:

SMD – 100 pF Bandwidth

So I think the way to do this is to pick the capacitance to put the self-resonant frequency in the VHF band, parallel another cap to put a second dip in the UHF band, and run with it. A back of the envelope calculation suggests 470 pF and 47 pF, but that obviously depends on a bunch of other imponderables and I’ll just interrogate the heap until the right ones step forward.

Just to show the test fixture isn’t a complete piece of crap, here’s a 12 pF cap resonating up around 850 MHz:

SMD – 12 pF Bandwidth

For the combination of components, sweep speeds, bandwidths, and suchlike in effect, the spectrum analyzer’s noise floor is down around -75 dBm. I think the 12 pF cap is actually better than it looks, but I didn’t fiddle around with a narrower resolution bandwidth.
2011-11-09
Glass Chip Flat

Having had trouble with tire liners eroding the rear tube, I went with just a tube and a Kevlar belted Marathon tire. Somewhat to my surprise, that lasted for most of the riding season, but a recent trip had a protracted rest stop:

Glass chip in tire

The puncture came from a knife-edged glass chip that avoided most of the Kevlar belt inside the tire:

Glass chip – detail

I think even a tire liner wouldn’t help with this one.

Other than that, the tube was in fine shape, so I’ll probably patch it and toss it back in the bike pack. Tire liners prevent most flats from gashes along the midline of the tire, but …

2011-11-03
Praying Mantis

Praying Mantis on bike rack

We met this Praying Mantis on the bike rack outside Skinner Hall at Vassar College. Even knowing they’re harmless, I’d have trouble picking it up; we parked on the other end of the rack.

If these things were any bigger, they’d be terrifying…

2011-10-29
Flex-fatigued Helmet Cable

I cable-tied the mic/earphone cable on Mary’s bike helmet to a rib on the fancy air vents near the back end, hoping that would reduce the inevitable flexing. Alas, it didn’t work out that way and the cable lasted only two seasons. This cut-away view shows the pulverized shield braid inside the jacket:

Fatigue-failed helmet cable

The symptoms were totally baffling: the mic worked perfectly, but the earphones cut out for at most a few syllables. Of course, I can’t wear her helmet and it only failed occasionally while riding. I barked up several wrong trees, until it got so bad that I could make it fail in the garage while listening to the local NWS weather radio station.

I spliced in a new USB male-A connector and (re-)discovered that the braid seems to be aluminum, rather than tinned copper. In any event, the wire is completely unsolderable; I crimped the braid from the new connector to a clean section of the old braid. The braid serves only as an electrostatic shield, as it’s not connected to anything on the helmet end. That should suffice until I rebuild the headsets this winter.

2011-10-20

KG-UV3D GPS+Voice: Box Model

The first pass at the box that will eventually hold the GPS+voice interface for the KG-UV3D radio looks like this, from the end that engages the alignment tabs on the bottom of the radio:

Case Solid Model - Tab End View - Fit — Case Solid Model – Tab End View – Fit

The other end has the opening for the TT3’s serial connector to the GPS receiver, a probably too-small hole for the external battery pack cable / helmet cable / PTT cable, and a hole on the side for the radio mic/speaker cables.

Case Solid Model - Connector End View - Fit — Case Solid Model – Connector End View – Fit

The serial connector opening has a built-in support plate that’s the shape shrunken by 5% so it’s easy to punch out. That worked surprisingly well; the line just above the right edge isn’t a break, it’s a stack of Reversal Zits. This version is rectangular; the solid model shows the proper D shape.

KG-UV3D box - connector hole support removal — KG-UV3D box – connector hole support removal

The bottom has battery contact recesses and counterbores (if that’s the right term for a molded feature) for the PCB mounting screws. In retrospect, those holes should be tapping diameter and the screws inserted from the top, through the PCB.

Case Solid Model - Battery Contact View - Fit — Case Solid Model – Battery Contact View – Fit

The colors mark individual pieces that get glued together. I can probably reduce the wall thickness on the top & bottom by three threads, which is in the nature of fine tuning. The latch mechanism that holds this affair to the radio is conspicuous by its absence…

The OpenSCAD source code:

// Wouxun KB-UV3D Battery Pack Case
// Ed Nisley KE4ZNU September 2011

include </home/ed/Thing-O-Matic/lib/MCAD/units.scad>
include </home/ed/Thing-O-Matic/Useful Sizes.scad>
include </home/ed/Thing-O-Matic/lib/visibone_colors.scad>

// Layout options

Layout = "Fit";		// Envelope Plate Base Lid Shell Fit Buildx ScrewSupport
								// PlugPlate

//- Extrusion parameters must match reality!
//  Print with +1 shells and 3 solid layers
//  Use 210 C extrusion temperature to improve layer bonding

ThreadThick = 0.33;
ThreadWidth = 2.0 * ThreadThick;

HoleWindage = 0.2;

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

Protrusion = 0.1;			// make holes end cleanly

BuildOffset = 2.0;			// clearance for build layout

//----------------------
//- Case dimensions

CaseOverallHeight = 40;
CaseOverallWidth = 56;
CaseOverallLength = 80.0;

PlateWidthMin = 53.0;			// plate interfacing with radio contacts
PlateWidthMax = 54.5;
PlateLength = 75.0;
PlateThick = IntegerMultiple(2.0,ThreadThick);

ContactWidth = 7.0 + HoleWindage;
ContactLength = 7.0 + HoleWindage;
ContactRecess = 2*ThreadThick;	// recess for contact metal plate
ContactGapX = 10.5;				// X space between contacts
Contact1Y = 53.0;				// offset from base
Contact2Y = 56.5;

BaseWidthInner = PlateWidthMin;
BaseWidthOuter = CaseOverallWidth;
BaseLength = CaseOverallHeight;
BaseThick = 1.0;
BaseWidthTaper = 5.0;

BaseOpeningMax = 42.0;
BaseOpeningMin = 33.0;
BaseOpeningY = 5.25;
BaseOpeningDepth = 2.0;

BaseTabWidth = 6.0;
BaseTabThick = 2.0;
BaseTabGap = 7.0;
BaseTabOC = BaseTabWidth + BaseTabGap;

BaseToothBase = 6.0;
BaseToothTip = 3.0;
BaseToothThick = 2.0;
BaseToothOC = BaseTabOC;

WedgeAngle = atan(BaseWidthTaper/((BaseWidthOuter - BaseWidthInner)/2));
echo(str("Plate & Shell Wedge Angle: ",WedgeAngle));

BaseEndLip = ThreadThick;			// should be 0.25 mm or so
BaseEndWidth = (PlateWidthMin - 3*BaseToothBase - 2*BaseToothTip)/2;
BaseEndAngle = atan((BaseOpeningDepth - BaseEndLip)/BaseOpeningY);

echo(str("Plate End Angle: ",BaseEndAngle));

PCBWidth = 2.00 * inch;
PCBLength = 2.75 * inch;
PCBMargin = Head2_56;
PCBClearBottom = IntegerMultiple(2*Nut2_56Thick,ThreadThick);
PCBHoleDia = Tap2_56;
PCBHoleY = 2.50 * inch;
PCBHoleX = 1.75 * inch;

echo(str("PCB Mounting Holes OC X: ",PCBHoleX," Y: ",PCBHoleY));
echo(str("       bottom clearance: ",PCBClearBottom));

ShellHeight = CaseOverallHeight - PlateThick;
ShellWidth = CaseOverallWidth;
ShellLength = PlateLength;
ShellWallX = IntegerMultiple((ShellWidth - PCBWidth)/2,ThreadWidth);
ShellWallY = IntegerMultiple((ShellLength - PCBLength)/2,ThreadWidth);
ShellWallMax = max(ShellWallX,ShellWallY);

echo(str("Wall thick X: ",ShellWallX," Y: ",ShellWallY));

LidThick = IntegerMultiple(1.0,ThreadThick);
LidMargin = IntegerMultiple(1.0,ThreadWidth);
LidWidth = ShellWidth - 2*LidMargin;
LidLength = ShellLength - 2*LidMargin;

LidScrewHead = Head3_48;
LidScrewTap = Tap3_48;
LidScrewClear = Clear3_48;
LidScrewLength = 5.0;
LidScrewOffsetX = ShellWidth/2 - LidMargin - 0.75*LidScrewHead;
LidScrewOffsetY = ShellLength/2 - LidMargin - 0.75*LidScrewHead;

HTCableDia = 5.0;
HTCableAspect = 2.0;			// width of hole
HTCableY = 65;
HTCableZ = 10;

SerialZ = ShellHeight - LidThick - 12.0;

BikeCableDia = 5.0;
BikeCableAspect = 1.5;
BikeCableX = -20;
BikeCableZ = 15;

JackOC = 11.20;						// 14.25 OD - (3.58 + 2.58)/2

JackScrewDia = 4.6;
JackScrewOffsetX = 1.00;
JackScrewOffsetY = 5.25;				//  mounting screw to edge of lower recess

PlugBaseWidth = 9.25;				// lower section of plate
PlugBaseLength = 22.0;
PlugBaseThick = 2.5;
PlugBaseRadius = 1.75;

Plug3Offset = 5.25;					// edge of base recess to 3.5 mm jack

Plug2BezelDia = 7.1;				// 2.5 mm plug
Plug2BezelThick = 1.04;
Plug2ScrewDia = 6.0;
Plug3ScrewLength = 3.0;

Plug3BezelDia = 8.13;				// 3.5 mm plug
Plug3BezelThick = 1.6;
Plug3ScrewDia = 7.95;
Plug3ScrewLength = 4.0;

PlugFillOffsetX = JackScrewOffsetX - 0.5;		// base recess CL to fill CL
PlugFillOffsetY = -10.5;				//  ... to edge of fill plate
PlugFillWidth = 11.0;
PlugFillLength = 34.00;
PlugFillThick = 3.0;
PlugFillRadius1 = 1.5;
PlugFillRadius2 = 4.5;

PlugFillOffsetYTotal = 0;

//----------------------
// 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);

}

//- Hack job for DB-9 (DE-9) panel opening
//  Snug fit around the shell surrounding the male pins
//  DB-9 should mount on outside, but if it's already soldered to the board,
//   that doesn't work and you must mount it inside the box

module DSubMin9(Height=1.0) {

  union() {

	linear_extrude(height=Height,center=false) {
	  hull() {
/*
		translate([-(19.28+0.13)/2,(10.72+0.13)/2,0])			// rectangular outline
		  circle(r=3.05/2,$fn=8);
		translate([-(19.28+0.13)/2,-(10.72+0.13)/2,0])
		  circle(r=3.05/2,$fn=8);
		translate([ (19.28+0.13)/2,(10.72+0.13)/2,0])
		  circle(r=3.05/2,$fn=8);
		translate([ (19.28+0.13)/2,-(10.72+0.13)/2,0])
		  circle(r=3.05/2,$fn=8);
*/
		translate([-(17.0+0.05)/2,-(8.48+0.05)/2,0])
		  circle(r=0.105*inch,$fn=8);
		translate([ (17.0+0.05)/2,-(8.48+0.05)/2,0])
		  circle(r=0.105*inch,$fn=8);
		translate([ (15.5+0.05)/2, (8.48+0.05)/2,0])
		  circle(r=0.105*inch,$fn=8);
		translate([-(15.5+0.05)/2, (8.48+0.05)/2,0])
		  circle(r=0.105*inch,$fn=8);
	  }
	  hull() {
		translate([-24.99/2,0,0])
		  circle(r=3.05/2,$fn=8);
		translate([ 24.99/2,0,0])
		  circle(r=3.05/2,$fn=8);
	  }
	}
  }

}

//-------------------

//- Overall case outline
//  This defines the mating taper into the radio shell

module CaseEnvelope(Length=1) {

	rotate([90,0,0])
	  linear_extrude(height=Length,center=true,convexity=5)
		polygon(points=[
				  [-BaseWidthOuter/2,BaseLength],
				  [-BaseWidthOuter/2,BaseWidthTaper],
				  [-BaseWidthInner/2,0],
				  [-BaseOpeningMax/2,0],

				  [ BaseOpeningMax/2,0],
				  [ BaseWidthInner/2,0],

				  [ BaseWidthOuter/2,BaseWidthTaper],

				  [ BaseWidthOuter/2,BaseLength]
				],
				convexity=1
		);

}

//- Battery contact plate recess
//  This gets subtracted from the bottom plate in two places

module Contact() {

  union() {
	translate([0,0,-(ContactRecess - Protrusion)/2])
	  cube([ContactWidth,ContactLength,(ContactRecess + Protrusion)],center=true);
	translate([0,0,-(PlateThick + Protrusion)])
	PolyCyl(Clear3_48,(PlateThick + 2*Protrusion));
	translate([0,0,-(ContactRecess + Head3_48Thick/3)])
	  PolyCyl(Head3_48,Head3_48Thick);				// allow for solder blob
  }
}

//- Back interface plate with battery contacts

module Plate() {

  difference() {

	translate([0,PlateLength/2,0])
	  intersection() {
		translate([0,0,PlateThick])
		  rotate([180,0,0])
			CaseEnvelope(PlateLength);
	  translate([-PlateWidthMax/2,-PlateLength/2,0])
		cube([PlateWidthMax,PlateLength,PlateThick],center=false);
	  }

	translate([-(ContactGapX/2 + ContactWidth/2),(Contact1Y + ContactLength/2),PlateThick])
	  Contact();
	translate([+(ContactGapX/2 + ContactWidth/2),(Contact2Y + ContactLength/2),PlateThick])
	  Contact();

	translate([0,PlateLength/2,0])
	  PCBHoles(PCBHoleDia,PlateThick);

	translate([0,PlateLength/2,(PlateThick - 2*Head2_56Thick/3)])
	  PCBHoles(IntegerMultiple(Head2_56,ThreadWidth),IntegerMultiple(Head2_56Thick,ThreadThick));
  }

}

//- Radio bottom locating feature
//  This polygon gets subtracted from the battery pack base

module RadioBase() {

linear_extrude(height=(BaseOpeningDepth + Protrusion),center=false,convexity=5)
  polygon(points=[
			[-BaseOpeningMax/2,-Protrusion],

			[-BaseOpeningMin/2,BaseOpeningY],
			[-(BaseToothOC/2 + BaseToothBase/2),BaseOpeningY],

			[-(BaseToothOC/2 + BaseToothTip/2),(BaseOpeningY - BaseToothThick)],
			[-(BaseToothOC/2 - BaseToothTip/2),(BaseOpeningY - BaseToothThick)],
			[-(BaseToothOC/2 - BaseToothBase/2),BaseOpeningY],

			[ (BaseToothOC/2 - BaseToothBase/2),BaseOpeningY],
			[ (BaseToothOC/2 - BaseToothTip/2),(BaseOpeningY - BaseToothThick)],
			[ (BaseToothOC/2 + BaseToothTip/2),(BaseOpeningY - BaseToothThick)],
			[ (BaseToothOC/2 + BaseToothBase/2),BaseOpeningY],
			[ BaseOpeningMin/2,BaseOpeningY],

			[ BaseOpeningMax/2,-Protrusion],

			[ (BaseTabOC + BaseTabWidth/2),-Protrusion],
			[ (BaseTabOC + BaseTabWidth/2),BaseTabThick],
			[ (BaseTabOC - BaseTabWidth/2),BaseTabThick],
			[ (BaseTabOC - BaseTabWidth/2),-Protrusion],

			[ BaseTabWidth/2,-Protrusion],
			[ BaseTabWidth/2,BaseTabThick],
			[-BaseTabWidth/2,BaseTabThick],
			[-BaseTabWidth/2,-Protrusion],

			[-(BaseTabOC + BaseTabWidth/2),-Protrusion],
			[-(BaseTabOC + BaseTabWidth/2),BaseTabThick],
			[-(BaseTabOC - BaseTabWidth/2),BaseTabThick],
			[-(BaseTabOC - BaseTabWidth/2),-Protrusion],
		  ],
		  convexity=5
  );
}

//- PCB Mounting Holes

module PCBHoles(HoleDia=PCBHoleDia,Height=1.0) {

  for (x=[-1,1])
	for (y=[-1,1])
	  translate([(x*PCBHoleX/2),
				(y*PCBHoleY/2),
				-Protrusion])
		PolyCyl(HoleDia,(Height + 2*Protrusion));

}

//-- Battery pack base

module Base() {

  difference() {

	translate([0,0,(BaseThick + BaseOpeningDepth)/2])
	  rotate([-90,0,0])
		CaseEnvelope(BaseThick + BaseOpeningDepth);

	translate([0,0,BaseThick])
	  RadioBase();

	translate([(BaseToothOC + BaseTabWidth/2),
			  -(BaseThick + BaseEndLip)/tan(BaseEndAngle),
			  0])
	  rotate([BaseEndAngle,0,0])
		cube([BaseEndWidth,3*BaseOpeningY,BaseOpeningDepth],center=false);

	translate([-(BaseToothOC + BaseTabWidth/2 + BaseEndWidth),
			  -(BaseThick + BaseEndLip)/tan(BaseEndAngle),
			  0])
	  rotate([BaseEndAngle,0,0])
		cube([BaseEndWidth,3*BaseOpeningY,BaseOpeningDepth],center=false);
  }
}

//- Lid

module Lid(WithHoles = false) {

  translate([0,LidLength/2,LidThick/2])
	difference() {
	  cube([LidWidth,LidLength,LidThick],center=true);
	  if (WithHoles) {
		translate([LidScrewOffsetX,LidScrewOffsetY,-(LidThick/2 + Protrusion)])
		  PolyCyl(LidScrewClear,(LidThick + 2*Protrusion));
		translate([-LidScrewOffsetX,-LidScrewOffsetY,-(LidThick/2 + Protrusion)])
		  PolyCyl(LidScrewClear,(LidThick + 2*Protrusion));
	  }
	}
}

//- Lid screw support shape

module LidScrewSupport(WithHole = false) {

  SupportSize = IntegerMultiple(LidScrewHead,ThreadWidth);

  difference() {
	translate([0,0,LidScrewLength/2])
	cube([SupportSize,SupportSize,LidScrewLength],center=true);
	if (WithHole)
	  translate([0,0,-Protrusion])
		PolyCyl(LidScrewTap,(LidScrewLength + 2*Protrusion));
  }

  translate([-SupportSize/2,SupportSize/2,-2*SupportSize])
	rotate([90,0,0])
	  linear_extrude(height=SupportSize,center=false)
		polygon(points=[
				  [0,0],[0,2*SupportSize],[SupportSize,2*SupportSize]]);

}

//- Battery pack shell

module Shell() {

  union() {
	difference() {

	  translate([0,0,-PlateThick])
		intersection() {
		  CaseEnvelope(ShellLength);
		  translate([0,0,(ShellHeight/2 + PlateThick)])
			cube([ShellWidth,ShellLength,ShellHeight],center=true);
		}

	  translate([0,-LidLength/2,(ShellHeight - LidThick)])
		scale([1,1,2])				// ensure clean cut across top
		  Lid(false);

	  translate([0,0,
				((ShellHeight - PCBClearBottom - LidThick + Protrusion)/2 + PCBClearBottom)])
		cube([PCBWidth,PCBLength,
			 (ShellHeight - PCBClearBottom - LidThick + Protrusion)],
			 center=true);

	  render()
		difference() {
		  translate([0,0,ShellHeight/2])
			cube([(PCBWidth - 2*PCBMargin),
				(PCBLength - 2*PCBMargin),
				(ShellHeight + 2*Protrusion)],
				center=true);
		  for (x=[-1,1])
			for (y=[-1,1])
			  translate([(x*PCBHoleX/2),(y*PCBHoleY/2),-Protrusion])
				cylinder(r=PCBMargin,(ShellHeight + 2*Protrusion),$fn=4);
		}

	  PCBHoles(PCBMargin);

	  translate([-(PCBWidth/2 - Protrusion),(HTCableY - PlateLength/2),HTCableZ])
		rotate([0,-90,0])
		  scale([1/HTCableAspect,1,1])
			PolyCyl(HTCableDia,(ShellWallMax + 2*Protrusion),8);

	  translate([BikeCableX,(PCBLength/2 - Protrusion),BikeCableZ])
		rotate([0,90,90])
		  scale([1/BikeCableAspect,1,1])
			PolyCyl(BikeCableDia,(ShellWallMax + 2*Protrusion),8);

	  translate([0,(PCBLength/2 - Protrusion),SerialZ])
		rotate([-90,0,0])
		  DSubMin9(ShellWallMax + 2*Protrusion);

	}

  	translate([0,(PCBLength/2 + ThreadWidth/2),SerialZ])
	  rotate([-90,0,0])
		scale([0.95,0.95,1])
		  DSubMin9(ShellWallY - ThreadWidth);		// thin support plug in hole

  }

}

//- Speaker-Mic plug mounting plate

module PlugPlate() {

  BaseX = PlugBaseWidth/2 - PlugBaseRadius;
  BaseY = PlugBaseLength/2 - PlugBaseRadius;

  difference() {
	union() {
	  linear_extrude(height=PlugBaseThick,center=false,convexity=3)
		hull() {
		  translate([-BaseX,-BaseY,0])
			circle(r=PlugBaseRadius,$fn=8);
		  translate([-BaseX, BaseY,0])
			circle(r=PlugBaseRadius,$fn=8);
		  translate([ BaseX, BaseY,0])
			circle(r=PlugBaseRadius,$fn=8);
		  translate([ BaseX,-BaseY,0])
			circle(r=PlugBaseRadius,$fn=8);
		}

	  translate([PlugFillOffsetX,
				(PlugFillLength/2 - PlugBaseLength/2 + PlugFillOffsetY),
				PlugBaseThick])
		linear_extrude(height=PlugFillThick,center=false,convexity=5)
		  hull() {
			translate([0,-(PlugFillLength/2 - PlugFillRadius2),0])
			  circle(r=PlugFillRadius2,$fn=10);
			translate([-(PlugFillWidth/2 - PlugFillRadius1),-PlugBaseLength/2,0])
			  circle(r=PlugFillRadius1,$fn=8);
			translate([-(PlugFillWidth/2 - PlugFillRadius1),
					  (PlugFillLength/2 - PlugFillRadius1),0])
			  circle(r=PlugFillRadius1,$fn=8);
			translate([(PlugFillWidth/2 - PlugFillRadius1),
					  (PlugFillLength/2 - PlugFillRadius1),0])
			  circle(r=PlugFillRadius1,$fn=8);
			translate([(PlugFillWidth/2 - PlugFillRadius1),-PlugBaseLength/2,0])
			  circle(r=PlugFillRadius1,$fn=8);
		  }
	}

	translate([0,-JackOC/2,-Protrusion])
	  rotate(360/16) {
		PolyCyl(Plug3BezelDia,(Plug3BezelThick + Protrusion),8);
		PolyCyl(Plug3ScrewDia,(PlugBaseThick + PlugFillThick + 2*Protrusion),8);
	  }

	translate([0,+JackOC/2,-Protrusion])
	  rotate(360/16) {
		PolyCyl(Plug2BezelDia,(Plug2BezelThick + Protrusion),8);
		PolyCyl(Plug2ScrewDia,(PlugBaseThick + PlugFillThick + 2*Protrusion),8);
	  }

	translate([JackScrewOffsetX,-(PlugBaseLength/2 + JackScrewOffsetY),0])
	  PolyCyl(JackScrewDia,(PlugBaseThick + PlugFillThick + Protrusion));
  }

}

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

ShowPegGrid();

if (Layout == "Envelope")
  CaseEnvelope(CaseOverallLength);

if (Layout == "Plate")
  Plate();

if (Layout == "Base")
  Base();

if (Layout == "Lid")
  Lid(true);

if (Layout == "ScrewSupport")
  LidScrewSupport(true);

if (Layout == "Shell")
  Shell();

if (Layout == "PlugPlate")
  PlugPlate();

if (Layout == "DSub")
  DSubMin9();

if (Layout == "Fit") {

  translate([0,-PlateLength/2,0]) {

	translate([0,0,PlateThick])
	  rotate([0,180,0])
		color(LOR) Plate();

	rotate([90,0,0])
	  color(DYO) Base();

	translate([0,LidMargin,10 + (CaseOverallHeight - LidThick)])
	  color(MOR) Lid(true);

	translate([0,PlateLength/2,PlateThick])
	    color(MFG) render() Shell();

	translate([-(ShellWidth/2 +10),70,15])
	  rotate([0,-90,0])
		color(DDY) PlugPlate();
  }
}

if (Layout == "Build1") {

  translate([-20,-PlateLength/2,0])
	Plate();

    translate([10,0,0])
	rotate([0,0,-90])
	  Base();

}

if (Layout == "Build2") {

  translate([0,-LidLength/2,0])
	Lid(true);

}

if (Layout == "Build3") {

  translate([-20,0,0])
	Shell();

}

if (Layout == "Build4") {

  translate([0,0,(PlugBaseThick + PlugFillThick)])
	rotate([180,0,0])
	  PlugPlate();

}

2011-10-07

KG-UV3D GPS+Voice: Box

The previous iteration of GPS+voice interface boxes came from the Sherline CNC mill, with a considerable amount of huffing & puffing. I got the Thing-O-Matic to simplify that process…

The general idea is to build a box that clips onto the radio in place of the standard battery pack. External power comes into the box and goes directly to the radio’s battery contacts; this will pose a problem with the Wouxun KG-UV3D, because it wants 7.2 V rather than the stepped-up 9 V from the Li-Ion packs I’ve been using. I think a three-wire power cord is in order: +9 V for the interface, +7.2 V for the radio, and common.

The box also interfaces with the radio’s mic and speaker jacks. Last time around, I made a gluing fixture to keep the plugs in alignment while the epoxy cured around the plugs in the plate, but maybe I can simplify that with 3D printing. Plastic will be better in one respect: the shells of the two plugs must be electrically isolated.

This first-pass (*) approximation shows the three tabs on the pack that engage the radio’s base:

KG-UV3D Interface Box prototype – right side

A detail of those tabs, as seen from the bottom:

KG-UV3D Interface Box prototype – end tabs

The ICOM IC-Z1A battery pack had a set of slip-in alignment features that held the pack on the radio, so two strips of tape sufficed to hold the interface box in place. Each Wouxun battery pack includes a spring-loaded latching mechanism that engages a pair of ramped tabs on the radio body that hold the pack against the spring-loaded battery contacts. That means I must come up with an actual latch of some sort to oppose the contact springs, but I haven’t figured that out yet.

The solid model, with the plug mounting plate floating beside it, looks like this:

Case Solid Model – Tab End View – Fit

Tomorrow, the solid modeling…

* It’s actually the third printing of the bottom plate with the three tabs and the base plate with the battery contacts. That’s how I figured out the 0. 5% shrinkage thing.

[Update: The sketch with the dimensions emerged from beneath a pile o’ stuff…]

Wouxun KG-UV3D Battery Pack Dimensions

2011-10-06