Category: Software

General-purpose computers doing something specific

Copying Video Files From Action Cameras to a NAS Drive

For unknown reasons, a recent VLC update caused it to ignore uppercase file extensions: MP4 and AVI files no longer appear in its directory listings, while mp4 and avi files do. The least-awful solution involved renaming the files after copying them:

find /mnt/video -name \*AVI -print0 | xargs -0 rename -v -f 's/AVI/avi/'
find /mnt/video -name \*MP4 -print0 | xargs -0 rename -v -f 's/MP4/mp4/'
find /mnt/video -name \*THM -print0 | xargs -0 rename -v -f 's/THM/thm/'

Yup, that scans the whole drive every time, which takes care of stray files, manual tweaks, and suchlike. The THM files are useless thumbnails; I should just delete them.

While I had the hood up, I listed the remaining space on the NAS drive and cleaned up a few misfeatures. I manually delete old video files / directories as needed, usually immediately after the script crashes for lack of room.

The Sony HDR-AS30V can act as a USB memory device, but it dependably segfaults the ExFAT driver; I now transfer its MicroSD card to an adapter and jam it into the media slot on the monitor, where it works fine.

Protip: always turn the AS30V on to verify the MicroSD card has seated correctly in its socket. Unfortunately, the socket can also hold Sony’s proprietary Memory Stick Micro cards (32 GB maximum capacity = roadkill), but the dual-use / dual-direction socket isn’t a snug fit around MicroSD cards. You (well, I) can insert a card so it looks fine, while sitting slightly canted and not making proper contact. The camera will kvetch about that and it’s easier to fix with the camera in hand.

I’ve disabled USB device automounting, as I vastly prefer to handle them manually, so the script asks for permission in order to mount the drives. The transfer requires about an hour, so I’ve extended the time the sudo password remains active.

The script lets both cards transfer data simultaneously; the Fly6 generally finishes first because it produces less data. That produces a jumbled progress display and the script waits for both drives to finish before continuing.

The Bash source code as a GitHub Gist:

	#!/bin/sh
	thisdate=$(date –rfc-3339=date)
	echo Date is $thisdate
	date
	# MicroSD cards not automounted
	as30v=/mnt/AS30V
	fly6=/mnt/Fly6
	sudo mount -o uid=ed /dev/sdb1 /mnt/AS30V/
	sudo mount -o uid=ed /dev/sdc1 /mnt/Fly6/
	# IOmega NAS defined as /mnt/video in fstab
	sudo mount /mnt/video
	mkdir /mnt/video/$thisdate
	rsync -ahu –progress $as30v/MP_ROOT/100ANV01/ /mnt/video/$thisdate &
	pid1=$!
	rsync -ahu –progress $fly6 /mnt/video
	date
	rc2=$?
	echo Fly6 RC is $rc2
	echo Waiting for $as30v
	wait $pid1
	rc=$(( $rc2 + $? ))
	date
	echo Overall RC: $rc
	if [ $rc -eq 0 ] ; then
	echo Fix capitalized extensions
	find /mnt/video -name \*AVI -print0 \| xargs -0 rename -v -f 's/AVI/avi/'
	find /mnt/video -name \*MP4 -print0 \| xargs -0 rename -v -f 's/MP4/mp4/'
	find /mnt/video -name \*THM -print0 \| xargs -0 rename -v -f 's/THM/thm/'
	echo Space remaining on NAS drive:
	df -h /mnt/video
	echo Remove files on AS30V
	rm $as30v/MP_ROOT/100ANV01/*
	echo Unmount cards and NAS
	sudo umount $as30v
	sudo umount $fly6
	sudo umount /mnt/video
	else
	echo Whoopsie: $rc
	fi

view raw savevideo.sh hosted with ❤ by GitHub

2017-05-19

Arduino Joystick

A bag of sub-one-dollar resistive joysticks arrived from halfway around the planet:

Arduino UNO - resistive joystick — Arduino UNO – resistive joystick

A quick-and-dirty test routine showed the sticks start out close to VCC/2:

Welcome to minicom 2.7

OPTIONS: I18n
Compiled on Feb  7 2016, 13:37:27.
Port /dev/ttyACM0, 10:23:45

Press CTRL-A Z for help on special keys

Joystick exercise
Ed Nisley - KE4ZNU - May 2017
00524 - 00513 - 1

That’s from minicom on the serial port, as the Arduino IDE’s built-in serial monitor ignores bare Carriage Return characters.

The joystick hat tilts ±25° from its spring-loaded center position, but the active region seems to cover only 15° of that arc, with a 5° dead zone around the center and 5° of overtravel at the limits. This is not a high-resolution instrument intended for fine motor control operations.

The analog input values range from 0x000 to 0x3FF across the active region. Aim the connector at your tummy to make the axes work the way you’d expect: left / down = minimum, right / up = maximum.

The delay(100) statements may or may not be needed for good analog input values, depending on some imponderables that seem not to apply for this lashup, but they pace the loop() to a reasonable update rate.

Pushing the hat toward the PCB activates the simple switch you can see in the picture. It requires an external pullup resistor (hence the INPUT_PULLUP configuration) and reports low = 0 when pressed.

Those are 0.125 inch (exactly!) holes on a 19.5×26.25 mm grid in a 26.5×34.25 mm PCB. Makes no sense to me, either.

The trivial Arduino source code as a GitHub Gist:

	// Joystick exercise

	#define JOYX A0
	#define JOYY A1
	#define BUTTON 7

	int JoyX,JoyY;
	boolean Button;

	//– Helper routine for printf()

	int s_putc(char c, FILE *t) {
	Serial.write(c);
	}


	void setup() {

	Serial.begin (9600);
	fdevopen(&s_putc,0); // set up serial output for printf()

	Serial.println ("Joystick exercise");
	Serial.println ("Ed Nisley – KE4ZNU – May 2017");

	pinMode(BUTTON,INPUT_PULLUP);
	}

	void loop() {

	JoyX = analogRead(JOYX);
	delay(100);
	JoyY = analogRead(JOYY);
	delay(100);
	Button = digitalRead(BUTTON);

	printf("%05d – %05d – %1d\r",JoyX,JoyY,Button);

	}

view raw JoyStickTest.ino hosted with ❤ by GitHub

2017-05-10

Dropbox Tour: To Keep Learning, Click Cancel

After copying a Digital Machinist column to my Dropbox folder, I went to the site to get the link, discovered they improved the UI, declined a Flash-based tour of the new features, and got this baffling confirmation dialog:

Dropbox – tour exit dialog

So. Many. Wrongs.

2017-05-06

Arduino vs. Significant Figures: BigNumber Library

The BigNumber library wraps the bc arbitrary precision calculator into a set of Arduino routines that seem like a reasonable basis for DDS calculations requiring more than the half-dozen digits of a floating point number or the limited range of scaled fixed point numbers tucked into an long int.

Treating programming as an experimental science produces some Arduino source code and its output as a GitHub Gist:

	// BigNumber exercise
	#include "BigNumber.h"

	//– Helper routine for printf()

	int s_putc(char c, FILE *t) {
	Serial.write(c);
	}

	void setup ()
	{
	Serial.begin (115200);
	fdevopen(&s_putc,0); // set up serial output for printf()

	Serial.println ("BigNumber exercise");
	Serial.println ("Ed Nisley – KE4ZNU – April 2017");

	#define WHOLES 10
	#define FRACTS 10

	printf("Fraction digits: %d\n",FRACTS);

	BigNumber::begin (FRACTS);
	char *pBigNumber;

	#define BUFFLEN (WHOLES + FRACTS)
	char NumString[BUFFLEN];

	BigNumber Tenth = "0.1"; // useful constants
	BigNumber Half = "0.5";
	BigNumber One = 1;
	BigNumber Two = 2;

	BigNumber ThirtyTwoBits = Two.pow(32);
	Serial.println(ThirtyTwoBits);

	BigNumber Oscillator = "125000000";
	Serial.println(Oscillator);

	BigNumber HertzPerCount;
	HertzPerCount = Oscillator / ThirtyTwoBits;
	Serial.println(HertzPerCount);

	BigNumber CountPerHertz;
	CountPerHertz = ThirtyTwoBits / Oscillator;
	Serial.println(CountPerHertz);

	BigNumber TestFreq = "60000";
	Serial.println(TestFreq);

	BigNumber DeltaPhi;

	DeltaPhi = TestFreq * CountPerHertz;
	Serial.println(DeltaPhi);

	long DeltaPhiL;
	DeltaPhiL = DeltaPhi;
	printf("Long: %ld\n",DeltaPhiL);

	Serial.println("0.1 Hz increment …");
	Serial.println(TestFreq + Tenth);

	DeltaPhi = (TestFreq + Tenth) * CountPerHertz;
	Serial.println(DeltaPhi);

	TestFreq = DeltaPhi * HertzPerCount;
	Serial.println(TestFreq);

	Serial.println("Rounding DeltaPhi up …");
	DeltaPhi += Half;
	Serial.println(DeltaPhi);
	TestFreq = DeltaPhi * HertzPerCount;
	Serial.println(TestFreq);

	pBigNumber = DeltaPhi.toString();
	printf("String: %04x → %s\n",pBigNumber,pBigNumber);
	free(pBigNumber);

	DeltaPhiL = DeltaPhi;
	printf("Unsigned: %ld\n",DeltaPhiL);

	pBigNumber = "59999.9";
	TestFreq = pBigNumber;
	Serial.println(TestFreq);

	DeltaPhi = TestFreq * CountPerHertz;
	Serial.println(DeltaPhi);

	Serial.println("Rounding DeltaPhi up …");
	DeltaPhi = TestFreq * CountPerHertz + Half;
	Serial.println(DeltaPhi);
	DeltaPhiL = DeltaPhi;

	int rc = snprintf(NumString,BUFFLEN,"%ld",DeltaPhiL);
	if (rc > 0 && rc < BUFFLEN) {
	printf("String length: %d\n",rc);
	}
	else {
	printf("Whoops: %d for %ld\n",rc,DeltaPhiL);
	strncpy(NumString,"123456789",sizeof(NumString));
	NumString[BUFFLEN-1] = 0;
	printf(" forced: %s\n",NumString);
	}
	printf("Back from string [%s]\n",NumString);
	DeltaPhi = NumString;
	Serial.println(DeltaPhi);
	TestFreq = DeltaPhi * HertzPerCount;
	Serial.println(TestFreq);

	}

	void loop () {

	}

view raw BigNumTest.ino hosted with ❤ by GitHub

	BigNumber exercise
	Ed Nisley – KE4ZNU – April 2017
	Fraction digits: 10
	4294967296
	125000000
	0.0291038304
	34.3597383680
	60000
	2061584.3020800000
	Long: 2061584
	0.1 Hz increment …
	60000.1000000000
	2061587.7380538368
	60000.0998830384
	Rounding DeltaPhi up …
	2061588.2380538368
	60000.1144349536
	String: 045e → 2061588.2380538368
	Unsigned: 2061588
	59999.9
	2061580.8661061632
	Rounding DeltaPhi up …
	2061581.3661061632
	String length: 7
	Back from string [2061581]
	2061581
	59999.9037798624

view raw BigNumTest.txt hosted with ❤ by GitHub

All that happened incrementally, as you might expect, with the intent of seeing how it works, rather than actually doing anything.

Some musings, in no particular order:

The library soaks up quite a hunk of program space:

Sketch uses 13304 bytes (43%) of program storage space. Maximum is 30720 bytes.

I think you could cut that back a little by eliminating unused bc routines, like square root / exponential / modulus.

That test code also blots up quite a bit of RAM:

Global variables use 508 bytes (24%) of dynamic memory, leaving 1540 bytes for local variables. Maximum is 2048 bytes.

All the BigNumber variables live inside the setup() function (or whatever it’s called in Arduino-speak), so they count as local variables. They’re four bytes each, excluding the dynamically allocated storage for the actual numbers at roughly a byte per digit. With 10 decimal places for all numbers, plus (maybe) an average of half a dozen integer digits, those ten BigNumbers soak up 200 = 10 × (4 + 16) bytes of precious RAM.

You can load a BigNumber from an int (not a long) or a string, then export the results to a long or a string. Given that controlling a DDS frequency with a knob involves mostly adding and subtracting a specific step size, strings would probably work fine, using snprintf() to jam the string equivalent of a long into a BigNumber as needed.

You must have about ten decimal places to hold enough significant figures in the HertzPerCount and CountPerHertz values. The library scale factor evidently forces all the numbers to have at least that many digits, with the decimal point stuck in front of them during string output conversions.

The biggest integers happen in the Oscillator and ThirtyTwoBits values, with 9 and 10 digits, respectively.

It looks useful, although I’m uncomfortable with the program space required. I have no way to estimate the program space for a simpleminded DDS controller, other than knowing it’ll be more than I estimate.

While poking around, however, I discovered the Arduino compiler does provide (limited) support for long long int variables. Given a 64 bit unit for simple arithmetic operations, a simpler implementation of fixed point numbers may be do-able: 32 bits for the integer and fraction should suffice! More on that shortly.

2017-05-05

Badge Lanyard Reel Mount

A certain young engineer of my acquaintance now carries an ID badge and, so I hear, works in a PCB design & test venue. Seeing as how her favorite color is purple, this seemed appropriate:

Badge Lanyard Reel - front - overall — Badge Lanyard Reel – front – overall

The guts came from Circuit Breaker Labs in the form of a recycled PCB trapped in acrylic resin atop a plastic housing with a spring-loaded reel inside.

It arrived with a plastic bullet at the end of the lanyard:

Badge Lanyard Reel - plastic bullet link — Badge Lanyard Reel – plastic bullet link

Which I immediately replaced with brass, because Steampunk:

Badge Lanyard Reel - bullet cross-drill — Badge Lanyard Reel – bullet cross-drill

That made the plastic housing look weak, so, in a series of stepwise refinements, I conjured a much better case from the vasty digital deep:

Badge Lanyard Reel - iterations — Badge Lanyard Reel – iterations

All of the many, many critical dimensions lie inside the case, where they can’t be measured accurately, so each of those iterations could improve only one or two features. The absolutely wonderful thing about OpenSCAD is having it regenerate the whole model after loosening, say, the carabiner slot by two thread thicknesses; you can do that with a full-on relational CAD drawing, but CAD drawings always seems like a lot of unnecessary work if I must figure out the equations anyway.

The back sports my favorite Hilbert Curve infill with a nicely textured finish:

Badge Lanyard Reel - rear - oblique — Badge Lanyard Reel – rear – oblique

It’d surely look better in solid brass with Hilbert curve etching.

Black PETG doesn’t photograph well, but at least you can see the M2 brass inserts:

Badge Lanyard Reel - lower interior — Badge Lanyard Reel – lower interior

The first prototype showed the inserts needed far more traction than the usual reamed holes could provide, so I added internal epoxy grooves in each hole:

Badge Lanyard Reel Mount - show — Badge Lanyard Reel Mount – show

Recessing the screw heads into the top plate made them more decorative and smoother to the touch. Button-head screws would be even smoother, but IMO didn’t look quite as bold.

After seeing how well the grooves worked, I must conjure a module tabulating all the inserts on hand and automagically generating the grooves.

The yellow star holds up the roof of the reel recess in the build layout:

Badge Lanyard Reel Mount - build layout - bottom — Badge Lanyard Reel Mount – build layout – bottom

Slic3r produced the rest of the support material for the carabiner exit slot:

Badge Lanyard Reel Mount - bottom - Slic3r support — Badge Lanyard Reel Mount – bottom – Slic3r support

Those two support lumps on the right don’t actually support anything, but tweaking the support settings to disable them also killed the useful support on the left; come to find out Slic3r’s modifier meshes don’t let you disable support generation.

The top plate required support all the way around the inside of the bezel:

Badge Lanyard Reel Mount - top - Slic3r support — Badge Lanyard Reel Mount – top – Slic3r support

I carved the original plastic housing in half, roughly along its midline, and discarded the bottom section with the belt clip (it’s on the far left of the scrap pile). The top section, with PCB firmly affixed, holds the lanyard reel and anchors the retracting spring in a central slotted peg. No pictures of that, as it’s either a loose assembly of parts or a spring-loaded bomb and I am not taking it apart again.

The lanyard passes through an eyelet that pays it out to the rotating reel. I’d definitely do that differently, were I building it from scratch, because mounting the eyelet in exactly the proper position to prevent the lanyard from stacking up on the reel and jamming against the inside of the housing turned out to be absolutely critical and nearly impossible.

The top plate presses the original housing against the carabiner, with the cut-off section inside the carabiner’s circular embrace, which just barely worked: the PCB bezel is a millimeter smaller than the shoulder of the housing.

All in all, I think it came out really well for a 3D printed object made by a guy who usually builds brackets:

Badge Lanyard Reel - front - oblique — Badge Lanyard Reel – front – oblique

I hope she likes it …

The OpenSCAD source code as a GitHub Gist:

	// Badge Lanyard Reel Mount
	// Ed Nisley KE4ZNU April 2017
	// Reel center at origin, lanyard exit toward +X

	Layout = "Show";

	Support = true;

	//- Extrusion parameters must match reality!

	ThreadThick = 0.20;
	ThreadWidth = 0.40;

	HoleWindage = 0.2;

	Protrusion = 0.05; // make holes end cleanly

	inch = 25.4;

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

	//———————-
	// Dimensions

	ID = 0; // for round things
	OD = 1;
	LENGTH = 2;

	Carabiner = [30.7,35.3,3.5]; // metal carabiner around original reel
	Latch = [6.0,-15,8.0]; // wire spring latch: offset from OD + thickness
	LatchAngle = 60; // max deflection angle to center from -X direction

	LatchPoints = [[0,0],
	[Latch[1]/tan(LatchAngle),0],
	[Latch[1]/tan(LatchAngle),-Latch[1]]]; // polygon in as-cut orientation

	echo(str("Latch polygon: ",LatchPoints));

	Screw = [2.0,3.8 + 0*ThreadWidth,10.0]; // M2 screw: ID = clear, OD = head
	ScrewHeadLength = 2.0;
	ScrewSides = 8;
	ScrewRecess = 5*ThreadThick;

	MountSides = ScrewSides; // suitably gritty corners

	MountThick = Screw[LENGTH] / cos(180/MountSides) + ScrewRecess + 2.0;

	Insert = [Screw[ID],3.4,4.0]; // brass insert for screws

	BCD = Carabiner[OD] + 2.5*Insert[OD];

	BoltAngles = [20,110]; // ± angles to bolt holes

	Reel = [5.3,25.5 + 2ThreadWidth,6.0 + 2ThreadThick]; // lanyard cord reel
	ShimThick = 2*ThreadThick; // covers open side of reel for better sliding

	Bezel = [31.0,32.0,7.5]; // PCB holder + shell, LENGTH = post + shell
	BezelSides = 6*4;
	BezelBlock = [5.5,7.5,3.6] + [ThreadWidth,ThreadWidth,ThreadThick]; // block around lanyard eyelet

	Eyelet = [3.5,4.5,3.0];

	Bullet = [2.0,6.5,2.0]; // brass badge holder, LENGTH = recess into mount

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

	//– Lanyard reel mockup

	module Reel() {

	cylinder(d=Reel[OD],h=Reel[LENGTH],center=true,$fn=6*4);

	}

	// Carabiner metal mockup
	// Some magic numbers lie in wait

	module Beener() {

	difference() {
	hull() {
	cylinder(d=Carabiner[OD],
	h=Carabiner[LENGTH] + 2*ThreadThick,
	center=true,$fn=BezelSides);
	translate([-Carabiner[OD]/2,0,0])
	cylinder(d=Carabiner[OD] – 2.0,
	h=Carabiner[LENGTH] + 2*ThreadThick,
	center=true,$fn=6*4);
	}
	cylinder(d=Carabiner[ID],
	h=2*Carabiner[LENGTH],
	center=true,$fn=BezelSides);
	translate([Carabiner[ID]/4,0,0])
	cube([Carabiner[ID],7.0,2*Carabiner[LENGTH]],center=true);
	}
	}

	// mockup of PCB holder atop remains of old mount with reel post
	// Z = 0 at midline of case

	module BezelMount() {

	rotate(180/BezelSides) {
	PolyCyl(Bezel[ID] + HoleWindage,MountThick,BezelSides); // PCB punches through mount
	PolyCyl(Bezel[OD] + HoleWindage,Bezel[LENGTH] – Reel[LENGTH]/2,BezelSides);
	}

	translate([Reel[OD]/2,0,BezelBlock[2]/2])
	scale([2,1,1])
	cube(BezelBlock,center=true);
	}

	// Main mount around holder & carabiner

	module Mount(Section="All") {

	render()
	difference() {
	hull() {
	for (a = BoltAngles) // spheres defining corners
	for (i=[-1,1])
	rotate(i*a)
	translate([BCD/2,0,0])
	sphere(d=MountThick,$fn=MountSides);
	cylinder(d=Carabiner[OD] + 4*ThreadWidth,
	h=MountThick,center=true); // capture carabiner ring
	}

	for (a = BoltAngles) // screw & insert holes, head recess
	for (i=[-1,1])
	rotate(i*a)
	translate([BCD/2,0,0])
	rotate(0i180/ScrewSides) {
	translate([0,0,-(Insert[LENGTH] + 2*ThreadThick)])
	PolyCyl(Insert[OD],
	Insert[LENGTH] + 2*ThreadThick + Protrusion,ScrewSides);
	for (k = [-2:2]) // epoxy retaining grooves
	translate([0,0,-(k3ThreadThick + Insert[LENGTH]/2)])
	PolyCyl(Insert[OD] + 1*ThreadWidth,
	2*ThreadThick,ScrewSides);
	PolyCyl(Screw[ID],Screw[LENGTH],ScrewSides);
	translate([0,0,MountThick/2 – ScrewRecess]) // recess screw heads
	PolyCyl(Screw[OD],Screw[LENGTH],ScrewSides);
	}

	translate([0,0,-1*ThreadThick]) // Minkowski Z extends only top surface!
	minkowski() { // space for metal carabiner
	Beener();
	// cube([ThreadWidth,ThreadWidth,2*ThreadThick]);
	cylinder(d=ThreadWidth,h=2*ThreadThick,$fn=6);
	}

	rotate([0,90,0]) rotate(180/6) // cord channel = brass tube clearance
	PolyCyl(Bullet[ID],Carabiner[ID],6);

	translate([Eyelet[LENGTH] + 2.0,0,0]) // eyelet, large end inward
	rotate([0,90,0]) rotate(180/6)
	PolyCyl(Eyelet[OD] + HoleWindage, Reel[OD]/2,6);

	if (false)
	translate([Reel[OD]/2 + Eyelet[LENGTH]/2,0,0]) // eyelet, small end outward
	rotate([0,90,0]) rotate(180/6)
	PolyCyl(Eyelet[ID],Eyelet[LENGTH],6);

	translate([(BCD/2 + MountThick/2)*cos(BoltAngles[0]) – Bullet[LENGTH],0,0]) // bullet recess
	rotate([0,90,0]) rotate(180/6)
	PolyCyl(Bullet[OD],Carabiner[ID],6);

	BezelMount(); // PCB holder clearance

	Reel(); // reel clearance

	translate([0,0,-(Reel[LENGTH] + ShimThick)/2]) // sliding plate on open side of reel
	cylinder(d=Reel[OD],h=ShimThick,center=true,$fn=6*4);

	translate([-Carabiner[OD]/2 + Latch[0],Latch[1],0])
	linear_extrude(height=Latch[2],center=true)
	polygon(LatchPoints);

	if (Section == "Upper") // display & build section cutting
	translate([0,0,-2*Carabiner[LENGTH]])
	cube(4*Carabiner,center=true);
	else if (Section == "Lower")
	translate([0,0,2*Carabiner[LENGTH]])
	cube(4*Carabiner,center=true);

	}

	if (Support) { // Completely ad-hoc support structures
	color("Yellow", Layout == "Show" ? 0.3 : 1.0) {
	if (false && Section == "Upper") {
	Spokes = BezelSides;
	Offset = 6*ThreadWidth;
	for (i = [2:Spokes – 2])
	rotate(i * 360/Spokes)
	translate([Offset,-ThreadWidth,0*(Carabiner[LENGTH]/2)/2])
	cube([Carabiner[OD]/2 – Offset – 0*ThreadWidth,
	2*ThreadWidth,
	Carabiner[LENGTH]/2],center=false);
	for (i = [0:Spokes – 1])
	rotate(i * 360/Spokes)
	translate([Offset,-ThreadWidth,0])
	cube([Bezel[OD]/2 – Offset,
	2*ThreadWidth,
	Bezel[LENGTH] – Reel[LENGTH]/2 – 2*ThreadThick],center=false);
	Bars = 7;
	render()
	difference() {
	union() {
	for (i = [-floor(Bars/2) : floor(Bars/2)])
	translate([-Carabiner[ID]/2,i*Carabiner[OD]/Bars,Carabiner[LENGTH]/4])
	cube([Carabiner[ID]/3,2*ThreadWidth,Carabiner[LENGTH]/2],center=true);
	translate([-Carabiner[ID]/2,0,ThreadThick/2])
	cube([Carabiner[ID]/3,Carabiner[ID],ThreadThick],center=true);
	}
	cylinder(d=Carabiner[ID] + 2*ThreadWidth,h=Carabiner[LENGTH]);
	}
	}
	if (Section == "Lower") {
	translate([0,0,-(Reel[LENGTH]/4 + ShimThick/2 – ThreadThick/2)])
	for (i = [0:8])
	rotate(i * 360/8)
	cube([Reel[OD] – 2*ThreadWidth,
	2*ThreadWidth,
	Reel[LENGTH]/2 + ShimThick – ThreadThick],center=true);
	if (false) {
	Bars = 7;
	render()
	difference() {
	union() {
	for (i = [-floor(Bars/2) : floor(Bars/2)])
	translate([-Carabiner[ID]/2,i*Carabiner[OD]/Bars,-Carabiner[LENGTH]/4])
	cube([Carabiner[ID]/3,2*ThreadWidth,Carabiner[LENGTH]/2],center=true);
	translate([-Carabiner[ID]/2,0,-ThreadThick/2])
	cube([Carabiner[ID]/3,Carabiner[ID],ThreadThick],center=true);
	}
	translate([0,0,-Carabiner[LENGTH]])
	cylinder(d=Carabiner[ID] + 0*ThreadWidth,h=Carabiner[LENGTH]);
	}
	}
	}
	}
	}

	}



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

	if (Layout == "Beener")
	Beener();

	if (Layout == "Mount")
	Mount();

	if (Layout == "Reel")
	Reel();

	if (Layout == "BezelMount")
	BezelMount();

	Gap = 25;
	if (Layout == "Show") {
	translate([0,0,Gap/2])
	Mount("Upper");
	translate([0,0,-Gap/2])
	Mount("Lower");
	color("Green",0.3)
	Beener();
	color("Brown",0.3)
	Reel();
	color("Red",0.3)
	translate([0,0,-(Reel[LENGTH] + ShimThick)/2])
	cylinder(d=Reel[OD],h=ShimThick,center=true,$fn=6*4);
	}

	if (Layout == "Build") {
	translate([(BCD + MountThick)/2,0,0])
	rotate(180)
	Mount("Upper");
	rotate([180,0,0])
	translate([-(BCD + MountThick)/2,0,0])
	Mount("Lower");
	}

	if (Layout == "BuildUpper")
	Mount("Upper");

	if (Layout == "BuildLower")
	rotate([180,0,0])
	Mount("Lower");

view raw Badge Lanyard Reel Mount.scad hosted with ❤ by GitHub

2017-04-28

Microscope 60 LED Ring Light Adapter

The Barbie-themed microscope light I built from an angel eye LED ring worked fine for the last six years (!), but a much brighter ring with 60 aimed 5 mm LEDs for $17 delivered from a US seller caught my eye:

Microscope 60 LED ring light - in use — Microscope 60 LED ring light – in use

Although this ring looks much more professional, it didn’t quite fit the microscope, being designed for a round snout rather than a squarish one. This snout has a 47-ish mm threaded ring intended for filters & suchlike, so I built an adapter between that and the 60 mm ID of the LED ring:

Microscope 60 LED Ring Light Adapter - top - Slic3r — Microscope 60 LED Ring Light Adapter – top – Slic3r

The ring came with three long knurled screws which I replaced with much tidier M3 socket-head screws going into those holes:

Microscope 60 LED ring light - assembled - top — Microscope 60 LED ring light – assembled – top

The part going into the snout threads is deliberately (honest!) a bit small, so I could wrap it with soft tape for a good friction fit. The Barbie Ring didn’t weigh anything and I wound up using squares of double-sticky foam tape; it could come to that for this ring, too.

The adapter features a taper on the bottom for no particularly good reason, as the field-of-view tapers inward, not outward:

Microscope 60 LED Ring Light Adapter - bottom - Slicer — Microscope 60 LED Ring Light Adapter – bottom – Slicer

Seen from the bug’s POV, it’s a rather impressive spectacle:

Microscope 60 LED ring light - assembled - bottom — Microscope 60 LED ring light – assembled – bottom

The control box sports a power switch and a brightness knob. Come to find out the ring is actually too bright at full throttle; a nice problem to have.

That was easy!

The OpenSCAD source code as a GitHub Gist:

	// LED Ring Light Mount – 60 mm ID ring
	// Ed Nisley KE4ZNU April 2017

	//- Extrusion parameters must match reality!

	ThreadThick = 0.25;
	ThreadWidth = 0.40;

	HoleWindage = 0.2;

	Protrusion = 0.1; // make holes end cleanly

	inch = 25.4;

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

	//———————-
	// Dimensions

	ID = 0;
	OD = 1;
	LENGTH = 2;

	ScopeThread = [43.0,46.5,4.0]; // scope snout thread, ID = minimum invisible

	LEDRing = [ScopeThread[ID],60.0,8.0];
	LEDScrewOffset = 4.0;
	LEDScrewOD = 3.0;
	LEDScrews = 3;

	OAH = ScopeThread[LENGTH] + LEDRing[LENGTH];

	NumSides = 34LEDScrews; // get symmetry for screws

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

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

	difference() {
	rotate(180/NumSides)
	union() {
	cylinder(d=ScopeThread[OD],h=OAH,$fn=NumSides);
	cylinder(d=LEDRing[OD],h=LEDRing[LENGTH],$fn=NumSides);
	}

	translate([0,0,-Protrusion])
	rotate(180/NumSides)
	cylinder(d=ScopeThread[ID],h=OAH + 2*Protrusion,$fn=NumSides);

	translate([0,0,-Protrusion])
	rotate(180/NumSides)
	cylinder(d1=LEDRing[OD] – 26ThreadWidth,
	d2=ScopeThread[ID],
	h=LEDRing[LENGTH] + Protrusion,$fn=NumSides);

	for (i=[0:LEDScrews-1])
	rotate(i*360/LEDScrews)
	translate([LEDRing[OD]/2 – LEDScrewOD,0,LEDRing[LENGTH] – LEDScrewOffset])
	rotate([0,90,0]) rotate(180/6)
	cylinder(d=LEDScrewOD,h=LEDScrewOD + Protrusion,$fn=6);
	}

view raw LED Ring Light Mount – 60 mm.scad hosted with ❤ by GitHub

2017-04-25

Cylindrical Cell Adapters

An octet of Eneloop AAA cells arrived, I wanted to measure their as-delivered charge (the package says “Factory Charged With SOLAR ENERGY”, so you know it’s good), and discovered I’d given away my AAA cell holders. You can actually get inter-series adapters on eBay, but what’s the fun in that? Plus, I didn’t want to delay gratification for a month; you know how it is.

Soooo:

AAA to AA Adapter - top - Slic3r — AAA to AA Adapter – top – Slic3r

It’s basically an AA-size sleeve that fits over the AAA cell, with a lathe-turned brass post conducting juice from the + terminal of the inner cell outward:

AAA to AA Adapter - parts — AAA to AA Adapter – parts

Not much to look at when it’s assembled:

AAA to AA Adapter - assembled — AAA to AA Adapter – assembled

The AAA cell fits deliberately loose, because this goes into a metal clip holding everything firmly in place for the battery tester:

AAA to AA Adapter - in use — AAA to AA Adapter – in use

The source code tabulates the sizes of several cylindrical cells, exactly zero other pairs of which have been tested; I expect most won’t work correctly. In particular, the table entries should include the contact button OD and thickness for each cell, so that I can turn out the proper terminal for each pair of cells. If I ever need a different adapter, I’ll beat some cooperation out of that, too.

Discovered I needed an adapter after breakfast, started testing cells after lunch. Life is good!

The OpenSCAD source code as a GitHub Gist:

	// Cylindrical cell adapters
	// Ed Nisley KE4ZNU April 2017

	//- Extrusion parameters must match reality!

	ThreadThick = 0.25;
	ThreadWidth = 0.40;

	HoleWindage = 0.2;

	Protrusion = 0.1; // make holes end cleanly

	inch = 25.4;

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

	//———————-
	// Dimensions

	OutCell = "AA"; // cell sizes
	InCell = "AAA";

	BottomClear = 3*ThreadThick; // shorten outer shell to allow base protrusion
	Terminal = [3.0,4.0,2.0]; // terminal: OD = nub dia, length = nub thickness

	NAME = 0;
	ID = 0; // for non-cell cylinders
	OD = 1;
	LENGTH = 2;

	Cells = [
	["AAAA",8.3,42.5],
	["AAA",10.5,44.5],
	["AA",14.5,50.5],
	["C",26.2,50],
	["D",34.2,61.5],
	["A23",10.3,28.5],
	["CR123",17.0,34.5],
	["18650",18.6,65.2]
	];

	Outer = search([OutCell],Cells,1,0)[0];
	Inner = search([InCell],Cells,1,0)[0];

	echo(str("Outer cell: ",Cells[Outer][NAME]));
	echo(str("Inner cell: ",Cells[Inner][NAME]));

	echo(str("Wall: ",Cells[Outer][OD] – (Cells[Inner][OD]/cos(180/NumSides) + 2*ThreadWidth)));

	Delta = Cells[Outer][LENGTH] – Cells[Inner][LENGTH];

	echo(str("Terminal OAL: ",Delta));
	echo(str(" … head: ",Terminal[LENGTH]));
	echo(str(" … shaft: ",Delta – Terminal[LENGTH]));

	NumSides = 3*4;

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

	}

	//———————-
	// Construct adapter

	module Adapter() {

	difference() {
	cylinder(d=Cells[Outer][OD],
	h=Cells[Outer][LENGTH] – BottomClear – Terminal[LENGTH],
	$fn=NumSides);

	translate([0,0,Delta – Terminal[LENGTH]])
	PolyCyl(Cells[Inner][OD] + 2*ThreadWidth,
	Cells[Inner][LENGTH] + Protrusion,
	NumSides);

	translate([0,0,-Protrusion])
	PolyCyl(Terminal[ID],
	2*Cells[Outer][LENGTH],
	6);
	}
	}

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

	Adapter();

view raw Cylindrical Cell Adapters.scad hosted with ❤ by GitHub

The original doodle:

AAA to AA Adapter - sketch — AAA to AA Adapter – sketch

2017-04-24

Category: Software

Copying Video Files From Action Cameras to a NAS Drive

Arduino Joystick

Dropbox Tour: To Keep Learning, Click Cancel

Arduino vs. Significant Figures: BigNumber Library

Badge Lanyard Reel Mount

Microscope 60 LED Ring Light Adapter

Cylindrical Cell Adapters