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.
Electrical & Electronic gadgets
Unlike the last CFL failure, this time I noticed the faint smell of electrical death near the Electronics Workbench, but I couldn’t track it down until the can light over the the Bench didn’t start:
The date code suggests it’s been in the fixture for over a decade, so I can’t complain. Having two unrelated bulbs fail within a week, after years of service, is surely coincidence. If another fails within a week or two, however, it will definitely be Enemy Action.
The Fly6 rear camera on my bike started giving off three long beeps and shutting down. Doing the reformatting / rebooting dance provides only temporary relief, so I think the card has failed:
The Fly6 can handle cards up to only 32 GB, which means I should stock up before they go the way of the 8 GB card shipped with the camera a few years ago.
Some back of the envelope calculations:
That’s only slightly more than the failure point of the Sony 64 GB MicroSDXC cards. The Fly6 writes about a third of the data per trip, so the card lasts longer on a calendar basis.
So now let’s find out how long the Samsung cards last …
Being a big fan of having a CNC machine know where it is, adding endstops (pronounded “home switches” in CNC parlance) to the Mostly Printed CNC axes seemed like a good idea:
All the mounts I could find fit bare microswitches of various sizes or seemed overly complex & bulky for what they accomplished. Rather than fiddle with screws and nut traps / inserts, a simple cable tie works just fine and makes the whole affair much smaller. Should you think cable ties aren’t secure enough, a strip of double stick tape will assuage your doubts.
A snippet of aluminum sheet moves the switch trip point out beyond the roller’s ball bearing:
I’m not convinced homing the Z axis at the bottom of its travel is the right thing to do, but it’s a start:
Unlike the stationary X and Y axes, the MPCNC’s Z axis rails move vertically in the middle block assembly; the switch moves downward on the rail until the actuator hits the block.
Perforce, the tooling mounted on the Z axis must stick out below the bottom of the tool carrier, which means the tool will hit the table before the switch hits the block. There should also be a probe input to support tool height setting.
The first mount fit perfectly, so I printed four more in one pass:
All three endstops plug into the RAMPS board, leaving the maximum endstop connections vacant:
Obviously, bare PCBs attached to the rails in mid-air aren’t compatible with milling metal, which I won’t be doing for quite a while. The electronic parts long to be inside enclosures with ventilation and maybe dust filtering, but …
The switches operate in normally open mode, closing when tripped. That’s backwards, of course, and defined to be completely irrelevant in the current context.
Seen from a high level, these switches set the absolute “machine coordinate system” origin, so the firmware travel limits can take effect. Marlin knows nothing about coordinate systems, but GRBL does: it can touch off to a fixture origin and generally do the right thing.
The OpenSCAD source code as a GitHub Gist:
| // Tour Easy Fairing Endstop Mount for Makerbot PCB | |
| // Ed Nisley KE4ZNU – 2017-11-07 | |
| /* [Build Options] */ | |
| Layout = "Build"; // [Build, Show, Block] | |
| Section = false; // show internal details | |
| /* [Extrusion] */ | |
| ThreadThick = 0.25; // [0.20, 0.25] | |
| ThreadWidth = 0.40; // [0.40] | |
| function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit); | |
| /* [Hidden] */ | |
| Protrusion = 0.01; // [0.01, 0.1] | |
| HoleWindage = 0.2; | |
| ID = 0; | |
| OD = 1; | |
| LENGTH = 2; | |
| /* [Sizes] */ | |
| RailOD = 23.5; | |
| Screw = [3.4,6.8,8.0]; // thread dia, head OD, screw length | |
| HoleOffset = [2.5,19.0/2]; // PCB mounting holes from PCB edge, rail center | |
| SwitchClear = [6.0,15,3.0]; // clearance around switch pins | |
| SwitchOffset = [6.0,0]; // center of switch from holes | |
| Strap = [5.5,50,2.0]; // nylon strap securing block to rail | |
| Block = [16.4,26.0,RailOD/2 + SwitchClear[2] + Strap[2] + 6*ThreadThick]; // basic block shape | |
| //- Adjust hole diameter to make the size come out right | |
| 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); | |
| } | |
| //- Shapes | |
| module PCBBlock() { | |
| difference() { | |
| cube(Block,center=true); | |
| translate([(SwitchOffset[0] + HoleOffset[0] – Block[0]/2),SwitchOffset[1],(Block[2] – SwitchClear[2] + Protrusion)/2]) | |
| cube(SwitchClear + [0,0,Protrusion],center=true); | |
| for (j=[-1,1]) | |
| translate([HoleOffset[0] – Block[0]/2,j*HoleOffset[1],(Block[2]/2 – Screw[LENGTH])]) | |
| rotate(180/6) | |
| if (false) // true = loose fit | |
| PolyCyl(Screw[ID],Screw[LENGTH] + Protrusion,6); | |
| else | |
| cylinder(d=Screw[ID],h=Screw[LENGTH] + Protrusion,$fn=6); | |
| translate([0,0,Block[2]/2 – SwitchClear[2] – Strap[2]/2 – 3*ThreadThick]) | |
| cube(Strap,center=true); | |
| if (Section) | |
| translate([Block[0]/2,0,0]) | |
| cube(Block + [0,2*Protrusion,2*Protrusion],center=true); | |
| } | |
| } | |
| module Mount() { | |
| difference() { | |
| translate([0,0,Block[2]/2]) | |
| PCBBlock(); | |
| rotate([0,90,0]) | |
| cylinder(d=RailOD,h=3*Block[0],center=true); | |
| } | |
| } | |
| //- Build things | |
| if (Layout == "Show") { | |
| Mount(); | |
| color("Yellow",0.5) | |
| rotate([0,90,0]) | |
| cylinder(d=RailOD,h=3*Block[0],center=true); | |
| } | |
| if (Layout == "Block") | |
| PCBBlock(); | |
| if (Layout == "Build") | |
| translate([0,0,Block[2]/2]) | |
| rotate([0,-90,0]) | |
| Mount(); |
The MPCNC kit includes five Automation Technology KL17H248-15-4A stepper motors:
If link rot should set in, a direct rip from the website:
NEMA 17 BIPOLAR STEPPER MOTOR, KL17H248-15-4A, 76 oz-in
Specifications:
Shaft: 5mm diameter with flat
Current Per Phase: 1.5A
Holding Torque: 5.5Kg.cm (76 oz-in)
Rated Voltage: 4.2V
NO.of Phase: 2
Step Angle: 1.8° ± 5%
Resistance Per Phase: 2.8Ω± 10%
Inductance Per Phase: 4.8mH± 20%
Insulation Class: Class B
Dielectric Strength: 100Mohm
Operation Temp Range: -20 ~ +40° C
Lead Wire: 22AWG / 750mm with connector to stepper motor driverRed- 1A
Green- 1B
Yellow- 2A
Blue- 2B
A nice torque curve:
The present MPCNC design wires the motors on each end of X / Y axes in series. Each motor has 2.8 Ω of DC resistance = 5.6 Ω total and, given the small wire gauge (allegedly 22 AWG on the motors and unspecified for any eBay cables) and six (!) teeny header pins in series along the wires for each winding, a total series resistance of 6 Ω seems reasonable and is, in fact, what I measure with an ohmmeter.
The stepper drivers arrived preset for 1 A peak:
The vertical scale is 500 mA/div. The waveform comes from a 10 mm move at 5000 mm/min = 83 mm/s, which is absurdly fast for such a machine, particularly seeing as how the default firmware limits it to 190 mm/min = 3 mm/s. Cutting speeds will be much lower than either of those.
The default DRV8825 current-setting pot setting was 600 mV, for a nominal current motor current of 1.2 A peak. That’s reasonably close to the measurement, all things considered.
However, because the motors run from a 12 V supply at 1 A, the winding and wiring losses mean they operate at a bit over 8 V: much much less than the nominal 24 and 32 V plotted in the torque curve. More voltage = faster response to microstep current changes = higher top speed. At sensible speeds, this surely does not matter.
The default DRV8825 stepper driver module jumpers select 32 microsteps = 6400 step/rev, a factor of four higher than the chart.
Part of the tweakage will be to sort that out; a 24 V supply may be in order. Driving each motor separately (as required for automatic de-racking homing) at 1.5 A/phase would require 3 1.5×√2 A/motor × 5 motors = 15 10.5 A, which seems excessive even to me, particularly in light of sending it across a RAMPS board. At 1 A/phase, you need 10 7 A, which falls within the realm of reason and would be kinder to the PLA motor mounts. It’s not clear boosting the motor voltage will produce any real benefit, although giving the drivers more headroom seems reasonable.
The GT2 drive belts have 2 mm pitch, so the 16 tooth drive pulleys move 32 mm/rev and require 200 step/mm, which seems high to me. At a nice round 100 mm/s, the steppers must tick along at 20 k step/s, half of Marlin’s top speed, which may explain some of the roughness around 80 mm/s.
The torque curve suggests the motors want to run under 200 RPM = 3.3 rev/s = 100 mm/s with the stock 16 tooth pulley. No problem with those numbers!
Using 16:1 microstepping would produce 3200 step/rev, 100 step/mm, thus half the step rate at any speed. Reducing the driver step frequency can’t possibly be a Bad Thing for Marlin.
To the end of documenting colors, connectors, and connections for the MPCNC stepper motors …
At the stepper motors:
The plug for the stepper at the end of the harness:
I opted to match the “pin 1” marks on the connectors, because that’s easy to remember, although it puts the pin latches on opposite sides:
Some obligatory Kapton tape holds the two connectors together.
The joint at the middle of the harness, with the near-end stepper cable on the upper left:
At the RAMPS driver end of the cable:
The Z-axis extension cable, with the stepper cable on the right:
I plugged the cables into the RAMPS board with the “pin 1” mark at the A1A2 end of the connectors.
With all the wires in place (and the GT2 drive belt still in its bag), I stuck masking tape tabs on the motor shafts, connected the RAMPS board, and verified the directions:
Although the Y axis needed reversing, both pairs of motors turned in the same direction!
Being that type of guy, I reversed the Y axis direction in the firmware configuration, because it’s easier for me to make all the physical connections look the same than (try to) remember to flip the Y axis connector whenever I must reconnect the cable to the driver.
A reader (you know who you are!) proposed an interesting project that will involve measuring audio passbands and suggested using white noise to show the entire shape on a spectrum analyzer. He pointed me at the NOISE 1B Noise Generator based on a PIC microcontroller, which led to trying out the same idea on an Arduino.
The first pass used the low bit from the Arduino runtime’s built-in random() function:
Well, that’s a tad pokey for audio: 54 μs/bit = 18.5 kHz. Turns out they use an algorithm based on multiplication and division to produce nice-looking numbers, but doing that to 32 bit quantities takes quite a while on an 8 bit microcontroller teleported from the mid 1990s.
The general idea is to send a bit from the end of a linear feedback shift register to an output to produce a randomly switching binary signal. Because successive values involve only shifts and XORs, it should trundle along at a pretty good clip and, indeed, it does:
I used the Galois optimization, rather than a traditional LFSR, because I only need one random bit and don’t care about the actual sequence of values. In round numbers, it spits out bits an order of magnitude faster at 6 μs/bit = 160 kHz.
For lack of anything smarter, I picked the first set of coefficients from the list of 32 bit maximal-length values at https://users.ece.cmu.edu/~koopman/lfsr/index.html:
0x80000057.
The spectrum looks pretty good, particularly if you’re only interested in the audio range way over on the left side:
It’s down 3 dB at 76 kHz, about half the 160 kHz bit flipping pace.
If you were fussy, you’d turn off the 1 ms timer interrupt to remove a slight jitter in the output.
It’s built with an old Arduino Pro Mini wired up to a counterfeit FTDI USB converter. Maybe this is the best thing I can do with it: put it in a box with a few audio filters for various noise colors and be done with it.
It occurs to me I could fire it into the 60 kHz preamp’s snout to measure the response over a fairly broad range while I’m waiting for better RF reception across the continent.
The Arduino source code as a GitHub Gist:
| // Quick test for random bit generation timing | |
| // Ed Nisley KE4ZNU – 2017-10-25 | |
| // Observe output bit on an oscilloscope | |
| // LFSR info https://en.wikipedia.org/wiki/Linear-feedback_shift_register | |
| // This code uses the Galois implementation | |
| // Coefficients from https://users.ece.cmu.edu/~koopman/lfsr/index.html | |
| #define PIN_RND 13 | |
| #include <Entropy.h> | |
| uint32_t Rnd; | |
| byte LowBit; | |
| void setup() { | |
| Serial.begin(57600); | |
| Serial.println("Random bit timing"); | |
| Serial.println("Ed Nisley KE4ZNU – 2017-10-25"); | |
| Entropy.initialize(); | |
| pinMode(PIN_RND,OUTPUT); | |
| uint32_t Seed = Entropy.random(); | |
| Serial.print("Seed: "); | |
| Serial.println(Seed,HEX); | |
| randomSeed(Seed); | |
| do { | |
| Rnd = random(); | |
| } while (!Rnd); // get nonzero initial value | |
| } | |
| void loop() { | |
| // digitalWrite(PIN_RND,Rnd & 1); // about 55 us/bit | |
| // Rnd = random(); | |
| LowBit = Rnd & 1; | |
| digitalWrite(PIN_RND,LowBit); // about 6 us/bit | |
| Rnd >>= 1; | |
| Rnd ^= LowBit ? 0x80000057ul : 0ul; | |
| } |
Epoxying a 100 kΩ thermistor to a 909 Ω resistor (because I have a bunch of them) serves as a simple heater tester:
It dissipates 450 mW, raising the temperature enough to let the PWM control kick in, but not enough to get scary hot.
Some heatstink tubing prevents reduces the likelihood of horrible accidents involving the 20 V motor / heater power supply:
Keeping it under 50 °C seems like a Good Idea:
Not that I have a need to heat anything, but the MOSFETs work!
The Smell of Molten Projects in the Morning 