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.
Making parts with mathematics
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!
While contemplating all the hocus-pocus and precision alignment involved in the DIY plotter project, it occurred to me you could conjure a plotter from a pair of steppers, two disks, a lifting mechanism, and not much else. The general idea resembles an Rθ plotter, with the paper glued to a turntable for the “theta” motion, but with the “radius” motion produced by pen(s) on another turntable:
The big circle is the turntable with radius R1, which might be a touch over 4.5 inches to fit an 8.5 inch octagon cut from ordinary Letter paper. The arc with radius R2 over on the right shows the pen path from the turntable’s center to its perimeter, centered at (R1/2,-R1) for convenience.
The grid paper represents the overall Cartesian grid containing the XY points you’d like to plot, like, for example, point Pxy in the upper right corner. The object of the game is to figure out how to rotate the turntable and pen holder to put Pxy directly under the pen at Ixy over near the right side, after which one might make a dot by lowering the pen. Drawing a continuous figure requires making very small motions between closely spaced points, using something like Bresenham’s line algorithm to generate the incremental coordinates or, for parametric curves like the SuperFormula, choosing a small parameter step size.
After flailing around for a while, I realized this requires finding the intersections of two circles after some coordinate transformations.
The offset between the two centers is (ΔX,ΔY) and the distance is R2 = sqrt(ΔX² + ΔY²). The angle between the +X axis and the pen wheel is α = atan2(ΔY,ΔX), which will be negative for this layout.
Start by transforming Pxy to polar coordinates PRθ, which produces the circle containing both Pxy and Ixy. A pen positioned at radius R from the center of the turntable will trace that circle and Ixy sits at the intersection of that circle with the pen rotating around its wheel.
The small rectangle with sides a and b has R as its diagonal, which means a² + b² = R² and the pointy angle γ = atan a/b.
The large triangle below that has base (R2 – a), height b, and hypotenuse R2, so (R2 – a)² + b² = R2².
Some plug-and-chug action produces a quadratic equation that you can solve for a as shown, solve for b using the first equation, find γ from atan a/b, then subtract γ from θ to get β, the angle spearing point Ixy. You can convert Rβ back to the original grid coordinates with the usual x = R cos β and y = R sin β.
Rotate the turntable by (θ – β) to put Pxy on the arc of the pen at Ixy.
The angle δ lies between the center-to-center line and Ixy. Knowing all the sides of that triangle, find δ = arccos (R2 – a) / R2 and turn the pen wheel by δ to put the pen at Ixy.
Lower the pen to make a dot.
Done!
Some marginal thinking …
I’m sure there’s a fancy way to do this with, surely, matrices or quaternions, but I can handle trig.
You could drive the steppers with a Marlin / RAMPS controller mapping between angles and linear G-Code coordinates, perhaps by choosing suitable steps-per-unit values to make the degrees (or some convenient decimal multiple / fraction thereof) correspond directly to linear distances.
You could generate points from an equation in, say, Python on a Raspberry Pi, apply all the transformations, convert the angles to G-Code, and fire them at a Marlin controller over USB.
Applying 16:1 microstepping to a stock 200 step/rev motor gives 0.113°/step, so at a 5 inch radius each step covers 0.01 inch. However, not all microsteps are moved equally and I expect the absolute per-step accuracy would be somewhere between OK and marginal. Most likely, given the application, even marginal accuracy wouldn’t matter in the least.
The pen wheel uses only 60-ish degrees of the motor’s rotation, but you could mount four-ish pens around a complete wheel, apply suitable pen lift-and-lower action and get multicolor plots.
You could gear down the steppers to get more steps per turntable revolution and way more steps per pen arc, perhaps using cheap & readily available RepRap printer GT2 pulleys / belts / shafts / bearings from the usual eBay sellers. A 16 tooth motor pulley driving a 60 tooth turntable pulley would improve the resolution by a factor of 3.75: more microsteps per commanded motion should make the actual motion come out better.
Tucking the paper atop the turntable and under the pen wheel could be a challenge. Perhaps mounting the whole pen assembly on a tilting plate would help?
Make all the workings visible FTW!
Some doodles leading up to the top diagram, complete with Bad Ideas and goofs …
Centering the pen wheel at a corner makes R2 = R1 * sqrt(2), which seems attractive, but seems overly large in retrospect:
Centering the pen wheel at (-R1,R1/2) with a radius of R1 obviously doesn’t work out, because the arc doesn’t reach the turntable pivot, so you can’t draw anything close to the center. At least I got to work out some step sizes.
A first attempt at coordinate transformation went nowhere:
After perusing the geometric / triangle solution, this came closer:
Configuring the knockoff RAMPS 1.4 board went reasonably smoothly:
The DC (n.b., not an AC) solid state relay in the foreground switches the 20 V laptop supply brick to the RAMPS shield atop the knockoff Arduino Mega 2560, controlled by the PS_ON pin (black wire), with +5 V from a pin in the AUX header (yellow wire). The SSR includes a ballast resistor limiting the current to 12 mA, with an inconspicuous red LED behind the black dot showing when the output is turned on.
Because it’s a DC SSR, polarity matters: the supply goes to the + terminal, the RAMPS power inputs to the – terminal.
I haven’t applied much of a load to to the SSR, but it works as expected. Define POWER_SUPPLY 1 and PS_DEFAULT_OFF so the boards starts up with the SSR turned off, then use M80 / M81 to turn it on / off as needed.
Remove D1 on the RAMPS board to isolate the Mega power from the +20 V supply. Stuffed as shown, the Mega draws 70 mA from the USB port, although an external 8 V (-ish) supply is always a good idea.
The stepper is a random NEMA 17 from the heap in a mount intended for a DIY plotter. I adjusted the tiny trimpots on all the boards for 400 mA peak = 250 mA RMS into the windings, after finding 250 mApk didn’t produce nearly enough mojo, even for a demonstration:
Just to get it running, I used DEFAULT_AXIS_STEPS_PER_UNIT = 100 step/mm, MAX_FEEDRATE 100 mm/s, and (for lack of anything better)
DEFAULT_*_ACCELERATION 1000. Those all depend the torque produced by the motor current, which is still way too low.
The endstops require X_???_ENDSTOP_INVERTING true.
I set the ?_BED_SIZE parameters to a generous 2000, with ?_MIN_POS equal to -SIZE/2 to put the origin in the middle where I prefer it, with a similar setting for the Z axis. Obviously, those numbers don’t correspond to any physical reality.
Three little 100 kΩ thermistors sprout from their header and produce reasonable temperatures, although (being cheap eBay parts) they may not match the Type 4 curve. I don’t have any heaters connected. All the over / under temperature lockouts are disabled, because I don’t care right now.
The G-Code parser wants uppercase command letters, which means I get to press the Caps Lock key for the first time in nearly forever!
The header along the right edge of the board connects to the LCD control board, which is another story.
The diffs for the Configuration.h and Configuration_adv.h files as a GitHub Gist:
| 77c77 | |
| < #define STRING_CONFIG_H_AUTHOR "(none, default config)" // Who made the changes. | |
| — | |
| > #define STRING_CONFIG_H_AUTHOR "(Ed Nisley – KE4ZNU)" // Who made the changes. | |
| 113c113 | |
| < #define BAUDRATE 250000 | |
| — | |
| > #define BAUDRATE 115200 | |
| 126c126 | |
| < //#define CUSTOM_MACHINE_NAME "3D Printer" | |
| — | |
| > #define CUSTOM_MACHINE_NAME "Not a 3D Printer" | |
| 130c130 | |
| < //#define MACHINE_UUID "00000000-0000-0000-0000-000000000000" | |
| — | |
| > #define MACHINE_UUID "89647f7b-2575-4809-bc90-5396f4376e02" | |
| 225c225 | |
| < #define POWER_SUPPLY 0 | |
| — | |
| > #define POWER_SUPPLY 1 | |
| 230c230 | |
| < //#define PS_DEFAULT_OFF | |
| — | |
| > #define PS_DEFAULT_OFF | |
| 285c285 | |
| < #define TEMP_SENSOR_0 1 | |
| — | |
| > #define TEMP_SENSOR_0 4 | |
| 290c290 | |
| < #define TEMP_SENSOR_BED 0 | |
| — | |
| > #define TEMP_SENSOR_BED 4 | |
| 304c304 | |
| < #define TEMP_WINDOW 1 // (degC) Window around target to start the residency timer x degC early. | |
| — | |
| > #define TEMP_WINDOW 2 // (degC) Window around target to start the residency timer x degC early. | |
| 309c309 | |
| < #define TEMP_BED_WINDOW 1 // (degC) Window around target to start the residency timer x degC early. | |
| — | |
| > #define TEMP_BED_WINDOW 2 // (degC) Window around target to start the residency timer x degC early. | |
| 324,325c324,325 | |
| < #define HEATER_0_MAXTEMP 275 | |
| < #define HEATER_1_MAXTEMP 275 | |
| — | |
| > #define HEATER_0_MAXTEMP 75 | |
| > #define HEATER_1_MAXTEMP 75 | |
| 329c329 | |
| < #define BED_MAXTEMP 150 | |
| — | |
| > #define BED_MAXTEMP 75 | |
| 417,418c417,418 | |
| < #define PREVENT_COLD_EXTRUSION | |
| < #define EXTRUDE_MINTEMP 170 | |
| — | |
| > //#define PREVENT_COLD_EXTRUSION | |
| > #define EXTRUDE_MINTEMP 50 | |
| 422c422 | |
| < #define PREVENT_LENGTHY_EXTRUDE | |
| — | |
| > //#define PREVENT_LENGTHY_EXTRUDE | |
| 441,442c441,442 | |
| < #define THERMAL_PROTECTION_HOTENDS // Enable thermal protection for all extruders | |
| < #define THERMAL_PROTECTION_BED // Enable thermal protection for the heated bed | |
| — | |
| > //#define THERMAL_PROTECTION_HOTENDS // Enable thermal protection for all extruders | |
| > //#define THERMAL_PROTECTION_BED // Enable thermal protection for the heated bed | |
| 476c476 | |
| < #define ENDSTOPPULLUPS // Comment this out (using // at the start of the line) to disable the endstop pullup resistors | |
| — | |
| > //#define ENDSTOPPULLUPS // Comment this out (using // at the start of the line) to disable the endstop pullup resistors | |
| 490,495c490,495 | |
| < #define X_MIN_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. | |
| < #define Y_MIN_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. | |
| < #define Z_MIN_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. | |
| < #define X_MAX_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. | |
| < #define Y_MAX_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. | |
| < #define Z_MAX_ENDSTOP_INVERTING false // set to true to invert the logic of the endstop. | |
| — | |
| > #define X_MIN_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. | |
| > #define Y_MIN_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. | |
| > #define Z_MIN_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. | |
| > #define X_MAX_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. | |
| > #define Y_MAX_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. | |
| > #define Z_MAX_ENDSTOP_INVERTING true // set to true to invert the logic of the endstop. | |
| 527c527 | |
| < #define DEFAULT_AXIS_STEPS_PER_UNIT { 80, 80, 4000, 500 } | |
| — | |
| > #define DEFAULT_AXIS_STEPS_PER_UNIT { 100, 100, 100, 100 } | |
| 534c534 | |
| < #define DEFAULT_MAX_FEEDRATE { 300, 300, 5, 25 } | |
| — | |
| > #define DEFAULT_MAX_FEEDRATE { 100, 100, 100, 100 } | |
| 542c542 | |
| < #define DEFAULT_MAX_ACCELERATION { 3000, 3000, 100, 10000 } | |
| — | |
| > #define DEFAULT_MAX_ACCELERATION { 1000, 1000, 1000, 1000 } | |
| 552,554c552,554 | |
| < #define DEFAULT_ACCELERATION 3000 // X, Y, Z and E acceleration for printing moves | |
| < #define DEFAULT_RETRACT_ACCELERATION 3000 // E acceleration for retracts | |
| < #define DEFAULT_TRAVEL_ACCELERATION 3000 // X, Y, Z acceleration for travel (non printing) moves | |
| — | |
| > #define DEFAULT_ACCELERATION 1000 // X, Y, Z and E acceleration for printing moves | |
| > #define DEFAULT_RETRACT_ACCELERATION 1000 // E acceleration for retracts | |
| > #define DEFAULT_TRAVEL_ACCELERATION 1000 // X, Y, Z acceleration for travel (non printing) moves | |
| 566,567c566,567 | |
| < #define DEFAULT_ZJERK 0.4 | |
| < #define DEFAULT_EJERK 5.0 | |
| — | |
| > #define DEFAULT_ZJERK 20.0 | |
| > #define DEFAULT_EJERK 20.0 | |
| 744c744 | |
| < #define INVERT_X_DIR false | |
| — | |
| > #define INVERT_X_DIR true | |
| 746c746 | |
| < #define INVERT_Z_DIR false | |
| — | |
| > #define INVERT_Z_DIR true | |
| 774,775c774,775 | |
| < #define X_BED_SIZE 200 | |
| < #define Y_BED_SIZE 200 | |
| — | |
| > #define X_BED_SIZE 2000 | |
| > #define Y_BED_SIZE 2000 | |
| 778,783c778,783 | |
| < #define X_MIN_POS 0 | |
| < #define Y_MIN_POS 0 | |
| < #define Z_MIN_POS 0 | |
| < #define X_MAX_POS X_BED_SIZE | |
| < #define Y_MAX_POS Y_BED_SIZE | |
| < #define Z_MAX_POS 200 | |
| — | |
| > #define X_MIN_POS -X_BED_SIZE/2 | |
| > #define Y_MIN_POS -Y_BED_SIZE/2 | |
| > #define Z_MIN_POS -1000 | |
| > #define X_MAX_POS X_BED_SIZE/2 | |
| > #define Y_MAX_POS Y_BED_SIZE/2 | |
| > #define Z_MAX_POS 1000 | |
| 1013c1013 | |
| < //#define EEPROM_SETTINGS // Enable for M500 and M501 commands | |
| — | |
| > #define EEPROM_SETTINGS // Enable for M500 and M501 commands | |
| 1023c1023 | |
| < #define HOST_KEEPALIVE_FEATURE // Disable this if your host doesn't like keepalive messages | |
| — | |
| > //#define HOST_KEEPALIVE_FEATURE // Disable this if your host doesn't like keepalive messages | |
| 1046,1047c1046,1047 | |
| < #define PREHEAT_1_TEMP_BED 70 | |
| < #define PREHEAT_1_FAN_SPEED 0 // Value from 0 to 255 | |
| — | |
| > #define PREHEAT_1_TEMP_BED 60 | |
| > #define PREHEAT_1_FAN_SPEED 255 // Value from 0 to 255 | |
| 1050,1051c1050,1051 | |
| < #define PREHEAT_2_TEMP_BED 110 | |
| < #define PREHEAT_2_FAN_SPEED 0 // Value from 0 to 255 | |
| — | |
| > #define PREHEAT_2_TEMP_BED 90 | |
| > #define PREHEAT_2_FAN_SPEED 255 // Value from 0 to 255 | |
| 1275c1275 | |
| < //#define REVERSE_ENCODER_DIRECTION | |
| — | |
| > #define REVERSE_ENCODER_DIRECTION | |
| 1290c1290 | |
| < //#define INDIVIDUAL_AXIS_HOMING_MENU | |
| — | |
| > #define INDIVIDUAL_AXIS_HOMING_MENU | |
| 1307,1308c1307,1308 | |
| < //#define LCD_FEEDBACK_FREQUENCY_DURATION_MS 100 | |
| < //#define LCD_FEEDBACK_FREQUENCY_HZ 1000 | |
| — | |
| > #define LCD_FEEDBACK_FREQUENCY_DURATION_MS 50 | |
| > #define LCD_FEEDBACK_FREQUENCY_HZ 700 | |
| 1379c1379 | |
| < //#define REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER | |
| — | |
| > #define REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER |
| 65,66c65,66 | |
| < #define THERMAL_PROTECTION_PERIOD 40 // Seconds | |
| < #define THERMAL_PROTECTION_HYSTERESIS 4 // Degrees Celsius | |
| — | |
| > #define THERMAL_PROTECTION_PERIOD 100 // Seconds | |
| > #define THERMAL_PROTECTION_HYSTERESIS 5 // Degrees Celsius | |
| 77c77 | |
| < #define WATCH_TEMP_PERIOD 20 // Seconds | |
| — | |
| > #define WATCH_TEMP_PERIOD 60 // Seconds | |
| 85c85 | |
| < #define THERMAL_PROTECTION_BED_PERIOD 20 // Seconds | |
| — | |
| > #define THERMAL_PROTECTION_BED_PERIOD 120 // Seconds | |
| 97c97 | |
| < #define WATCH_BED_TEMP_PERIOD 60 // Seconds | |
| — | |
| > #define WATCH_BED_TEMP_PERIOD 120 // Seconds | |
| 225c225 | |
| < * | |
| — | |
| > * | |
| 352c352 | |
| < #define HOMING_BUMP_DIVISOR {2, 2, 4} // Re-Bump Speed Divisor (Divides the Homing Feedrate) | |
| — | |
| > #define HOMING_BUMP_DIVISOR {4, 4, 4} // Re-Bump Speed Divisor (Divides the Homing Feedrate) | |
| 374c374 | |
| < #define DEFAULT_STEPPER_DEACTIVE_TIME 120 | |
| — | |
| > #define DEFAULT_STEPPER_DEACTIVE_TIME 0 | |
| 458c458 | |
| < //#define LCD_INFO_MENU | |
| — | |
| > #define LCD_INFO_MENU | |
| 461c461 | |
| < //#define STATUS_MESSAGE_SCROLLING | |
| — | |
| > #define STATUS_MESSAGE_SCROLLING | |
| 464c464 | |
| < //#define LCD_DECIMAL_SMALL_XY | |
| — | |
| > #define LCD_DECIMAL_SMALL_XY | |
| 467c467 | |
| < //#define LCD_TIMEOUT_TO_STATUS 15000 | |
| — | |
| > #define LCD_TIMEOUT_TO_STATUS 10000 | |
| 562c562 | |
| < #define XYZ_HOLLOW_FRAME | |
| — | |
| > //#define XYZ_HOLLOW_FRAME | |
| 565c565 | |
| < #define MENU_HOLLOW_FRAME | |
| — | |
| > //#define MENU_HOLLOW_FRAME | |
| 573c573 | |
| < //#define USE_SMALL_INFOFONT | |
| — | |
| > #define USE_SMALL_INFOFONT | |
| 752c752 | |
| < #define TX_BUFFER_SIZE 0 | |
| — | |
| > #define TX_BUFFER_SIZE 128 |
As part of recommissioning the lathe tailstock, I made some bushings to adapt Dremel sanding drums bands to an 8 mm shaft (in imitation of the grit drive wheels on the HP plotter):
They’re not all the same because the lad who’s building the plotter got to turn out his own bushings. We think the knurled version, with a setscrew to lock it on the shaft, will work better than adhesive-bonding the drum to the bushing.
The overall process starts with a rough 1/2 inch aluminum rod. Skim-cut to get a concentric surface and face the end smooth:
Then knurl it:
The skim cut makes the aluminum rod a loose fit inside the sanding band, but the knurling enlarges the diameter enough to make it a firm press fit and I think it’ll have enough traction to stay in place.
FWIW, the wheels in the LittleMachineShop knurling tool seem pretty bad: the central holes aren’t quite concentric with the cutting edge, the bores are a loose fit on the mounting screws, the wheels are much narrower than the slots they ride in, so they wobble uncontrollably. It’s not a fatal flaw, but they definitely produce a sub-par knurl.
Face off the front, cut the knurling down at each end, then part it off:
Clamp it in the Sherline mill, laser-spot the edges, set the origin in the middle, and center drill:
Drill and tap for a teeny M3 setscrew:
Clean out the chips, debur the hole, install the setscrew, and you’re half-done: do it again to get the second drive roller!
As part of coaching a student (and his father!) on their incredibly ambitious build-a-plotter-from-scratch project, I suggested stealing using HP’s grit-wheel paper drive, rather than fiddling with guide rods to move either the pen carrier or the entire paper platform. Dremel sanding drums seem about the right size and they had an 8 mm shaft harvested from a defunct printer, so a pair of mounts moves the project along:
The motor mount code is a hack job from my old NEMA17 mount and the code has a lot not to like. The bearing mount puts the bearing on the proper centerline using brute force copypasta and depends on friction to hold it in place. The two models should be integrated into the same file, the shaft centerline shouldn’t involve the printed thread width, and blah blah blah:
I had him turn the shaft adapter from an aluminum rod in the mini-lathe: he’s hooked.
The OpenSCAD source code as a GitHub Gist:
| // Ball bearing mount | |
| // Ed Nisley KE4ZNU 2017-10-09 | |
| //– Extrusion parameters | |
| ThreadThick = 0.20; | |
| ThreadWidth = 0.40; | |
| HoleWindage = 0.2; // enlarge hole dia by this amount | |
| function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit); | |
| Protrusion = 0.1; // make holes look good and joints intersect properly | |
| //– Useful sizes | |
| inch = 25.4; | |
| Tap10_32 = 0.159 * inch; | |
| Clear10_32 = 0.190 * inch; | |
| Head10_32 = 0.373 * inch; | |
| Head10_32Thick = 0.110 * inch; | |
| Nut10_32Dia = 0.433 * inch; | |
| Nut10_32Thick = 0.130 * inch; | |
| // Bearing sizes | |
| ID = 0; | |
| OD = 1; | |
| LENGTH = 2; | |
| Bearing = [8.0,22.0,7.0]; | |
| ShaftHeight = IntegerMultiple(25.2,ThreadWidth); // arbitrary or copied from motor mount | |
| WallThick = 3.0; | |
| //– Mount Sizes | |
| MountSize = Bearing[OD] + 2*WallThick; | |
| BaseThick = max(WallThick,ShaftHeight – MountSize/2); // baseplate | |
| StandBoltHead = IntegerMultiple(Head10_32,2); // bolt head rounded up | |
| StandBoltClear = 1.25 * StandBoltHead; | |
| StandBoltOC = IntegerMultiple(MountSize + StandBoltClear,2); | |
| StandLength = StandBoltOC + StandBoltClear; | |
| StandThick = StandBoltClear + WallThick; | |
| StandHeight = MountSize + BaseThick; | |
| Cutout = (StandLength – MountSize)/2; | |
| echo(str("Stand Base: ",StandLength," x ",StandThick," x ",BaseThick)); | |
| echo(str("Stand Bolt OC: ",StandBoltOC)); | |
| echo(str("Shaft Height:",ShaftHeight)); | |
| //———————- | |
| // 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); | |
| } | |
| //———————- | |
| // Put it together | |
| module BearingMount() { | |
| difference() { | |
| translate([BaseThick/2,0,StandThick/2]) | |
| cube([StandHeight,StandLength,StandThick],center=true); | |
| translate([0,0,-Protrusion]) | |
| PolyCyl(Bearing[OD],(StandThick + 2*Protrusion)); | |
| for (j=[-1,1]) // cutouts over bolts | |
| translate([-(StandHeight/2 – ShaftHeight + WallThick), | |
| j*(StandLength/2 – Cutout/2 + Protrusion/2), | |
| (WallThick + StandThick/2)]) | |
| cube([StandHeight, | |
| Cutout + Protrusion, | |
| StandThick],center=true); | |
| for (j=[-1,1]) // stand bolt holes – base | |
| translate([(MountSize/2 – Protrusion), | |
| j*StandBoltOC/2, | |
| WallThick + StandBoltClear/2]) | |
| rotate([0,90,0]) | |
| rotate(180/6) | |
| PolyCyl(Clear10_32,BaseThick + 2*Protrusion,6); | |
| for (j=[-1,1]) // stand bolt holes – back | |
| translate([0,j*StandBoltOC/2,-Protrusion]) | |
| rotate(180/6) | |
| PolyCyl(Clear10_32,StandThick + 2*Protrusion,6); | |
| translate([0,-(MountSize/2 – ThreadWidth/2),(StandThick – WallThick)/2 + WallThick]) | |
| rotate([90,180,0]) | |
| linear_extrude(ThreadWidth,convexity=10) | |
| text(text=str(ShaftHeight),size=6,spacing=1.20,font="Arial",halign="center",valign="center"); | |
| } | |
| } | |
| //———————- | |
| // Build it | |
| BearingMount(); | |
| // NEMA 17 stepper mount | |
| // Ed Nisley KE4ZNU August 2011 | |
| // Tweaked & thinned 2017-10-09 | |
| //– Extrusion parameters | |
| ThreadThick = 0.25; | |
| ThreadWidth = 0.4; | |
| HoleWindage = 0.3; // enlarge hole dia by this amount | |
| function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit); | |
| Protrusion = 0.1; // make holes look good and joints intersect properly | |
| //– Useful sizes | |
| inch = 25.4; | |
| Tap10_32 = 0.159 * inch; | |
| Clear10_32 = 0.190 * inch; | |
| Head10_32 = 0.373 * inch; | |
| Head10_32Thick = 0.110 * inch; | |
| Nut10_32Dia = 0.433 * inch; | |
| Nut10_32Thick = 0.130 * inch; | |
| NEMA17_ShaftDia = 5.0; | |
| NEMA17_ShaftLength = 24.0; | |
| NEMA17_PilotDia = 0.866 * inch; | |
| NEMA17_PilotLength = 0.080 * inch; | |
| NEMA17_BCD = 1.725 * inch; | |
| NEMA17_BoltDia = 3.5; | |
| NEMA17_BoltOC = 1.220 * inch; | |
| //– Mount Sizes | |
| MountWidth = IntegerMultiple(NEMA17_BCD,ThreadWidth); // use BCD for motor clearance | |
| MountThick = IntegerMultiple(4.0,ThreadThick); // for stiffness | |
| MountBoltDia = 3.0; | |
| StandThick = 3.0; // baseplate | |
| StrutThick = IntegerMultiple(3.0,ThreadWidth); // sides holding motor mount | |
| UprightLength = MountWidth + 2*StrutThick; | |
| StandBoltHead = IntegerMultiple(Head10_32,5); // bolt head rounded up | |
| StandBoltOC = IntegerMultiple(UprightLength + 2*StandBoltHead,5); | |
| StandLength = StandBoltOC + 2*StandBoltHead; | |
| StandWidth = 2*StandBoltHead; | |
| StandBoltClear = (StandLength – UprightLength)/2; // flat around bolt head | |
| MotorRecess = StandWidth – MountThick; | |
| ShaftHeight = IntegerMultiple(StandThick + MountWidth/2,ThreadWidth); | |
| echo(str("Stand Base: ",StandLength," x ",StandWidth," x ",StandThick)); | |
| echo(str("Stand Bolt OC: ",StandBoltOC)); | |
| echo(str("Shaft Height:",ShaftHeight)); | |
| echo(str("Strut Thick: ",StrutThick)); | |
| //———————- | |
| // 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); | |
| } | |
| //———————- | |
| // Model | |
| module MotorMount() { | |
| difference() { | |
| translate([StandThick/2,0,StandWidth/2]) | |
| cube([(MountWidth + StandThick),StandLength,StandWidth],center=true); | |
| translate([-Protrusion/2,0,StandWidth – (MotorRecess – Protrusion)/2]) | |
| cube([(MountWidth + Protrusion),MountWidth,(MotorRecess + Protrusion)],center=true); | |
| translate([0,0,-Protrusion]) // pilot hole | |
| PolyCyl(NEMA17_PilotDia,(MountThick + 2*Protrusion)); | |
| for (i=[-1,1]) // motor bolt holes | |
| for (j=[-1,1]) | |
| translate([i*NEMA17_BoltOC/2,j*NEMA17_BoltOC/2,-Protrusion]) | |
| PolyCyl(MountBoltDia,(MountThick + 2*Protrusion),6); | |
| for (j=[-1,1]) // cutouts over bolts | |
| translate([-Protrusion/2, | |
| j*((StandLength – StandBoltClear)/2 + Protrusion/2), | |
| StandWidth/2]) | |
| cube([(MountWidth + Protrusion), | |
| (StandBoltClear + Protrusion), | |
| (StandWidth + 2*Protrusion)],center=true); | |
| for (j=[-1,1]) // stand bolt holes | |
| translate([(MountWidth/2 – Protrusion),j*StandBoltOC/2,StandWidth/2]) | |
| rotate([0,90,0]) | |
| rotate(180/6) | |
| PolyCyl(Clear10_32,StandThick + 2*Protrusion,6); | |
| translate([0,-(UprightLength/2 – ThreadWidth/2),StandWidth/2]) | |
| rotate([90,180,0]) | |
| linear_extrude(ThreadWidth,convexity=10) | |
| text(text=str(ShaftHeight),size=6,spacing=1.20,font="Arial",halign="center",valign="center"); | |
| } | |
| } | |
| //———————- | |
| // Build it | |
| MotorMount(); | |
In the unlikely event our bikes need two running lights or, perhaps, a running light and a headlight, the solid model now builds mounts for the right side of the fairing, as before:
And for the left side:
Ahhh, chirality: love that word.
Those pix come from a cleaned-up version of the OpenSCAD code that finally gets the 3-axis rotations right, after a rip-and-replace rewrite to deliver the ball model with its origin in the center of the ball where it belonged and rotate the ring about its geometric center. Then the rotations become trivially easy and a slight hack job spits out a completely assembled model:
if (Component == "Complete") {
translate([-BracketHoleOC,0,0])
PlateBlank();
mirror(TiltMirror) {
translate([0,0,ClampOD/2]) {
rotate([-Roll,ToeIn,Tilt])
SlotBall();
rotate([-Roll,ToeIn,Tilt])
BallClamp();
}
}
}
However, putting the center of rotation directly over the center of the base plate means the ToeIn rotation shifts the bottom of the clamp ring along the X axis, where it can obstruct the mounting holes. Shifting the ring by a little bit:
ClampOD*sin(ToeIn/2)
… keeps the ring more-or-less centered on the top of the plate. That’s not quite the correct geometry, but it’s close enough for the small angles needed here.
Aiming the beam slightly higher makes a 400 lumen flashlight about as bright as any single LED in new car running lights:
You can just barely make out the snazzy new blue plate on the left side of the fairing.
A bike’s natural back-and-forth handlebar motion sweeps the beam across the lane, so I think there’s no real benefit from blinking.
The OpenSCAD source code as a GitHub Gist:
| // Tour Easy Fairing Flashlight Mount | |
| // Ed Nisley KE4ZNU – July 2017 | |
| // August 2017 – | |
| /* [Build Options] */ | |
| FlashName = "AnkerLC40"; // [AnkerLC40,AnkerLC90,J5TactV2,InnovaX5] | |
| Component = "Complete"; // [Ball, BallClamp, Mount, Plates, Bracket, Complete] | |
| Layout = "Show"; // [Build, Show] | |
| Support = false; | |
| MountSupport = false; | |
| /* [Extrusion] */ | |
| ThreadThick = 0.25; // [0.20, 0.25] | |
| ThreadWidth = 0.40; // [0.40] | |
| function IntegerMultiple(Size,Unit) = Unit * ceil(Size / Unit); | |
| Protrusion = 0.01; // [0.01, 0.1] | |
| HoleWindage = 0.2; | |
| /* [Fairing Mount] */ | |
| Side = "Right"; // [Right,Left] | |
| ToeIn = 0; // inward from ahead | |
| Tilt = 15; // upward from forward (M=20 E=15) | |
| Roll = 0; // outward from top | |
| //- Screws *c | |
| /* [Hidden] */ | |
| ID = 0; | |
| OD = 1; | |
| LENGTH = 2; | |
| /* [Screws and Inserts] */ | |
| ClampInsert = [3.0,4.2,8.0]; | |
| ClampScrew = [3.0,5.9,35.0]; // thread dia, head OD, screw length | |
| ClampScrewWasher = [3.0,6.75,0.5]; | |
| ClampScrewNut = [3.0,6.1,4.0]; // nyloc nut | |
| /* [Hidden] */ | |
| F_NAME = 0; | |
| F_GRIPOD = 1; | |
| F_GRIPLEN = 2; | |
| LightBodies = [ | |
| ["AnkerLC90",26.6,48.0], | |
| ["AnkerLC40",26.6,55.0], | |
| ["J5TactV2",25.0,30.0], | |
| ["InnovaX5",22.0,55.0] | |
| ]; | |
| //- Fairing Bracket | |
| // Magic numbers taken from the actual fairing mount | |
| /* [Hidden] */ | |
| inch = 25.4; | |
| BracketHoleOD = 0.25 * inch; // 1/4-20 bolt holes | |
| BracketHoleOC = 1.0 * inch; // fairing hole spacing | |
| // usually 1 inch, but 15/16 on one fairing | |
| Bracket = [48.0,16.3,3.6 – 0.6]; // fairing bracket end plate overall size | |
| BracketHoleOffset = (3/8) * inch; // end to hole center | |
| BracketM = 3.0; // endcap arc height | |
| BracketR = (pow(BracketM,2) + pow(Bracket[1],2)/4) / (2*BracketM); // … radius | |
| //- Base plate dimensions | |
| Plate = [100.0,30.0,6*ThreadThick + Bracket[2]]; | |
| PlateRad = Plate[1]/4; | |
| RoundEnds = true; | |
| echo(str("Base plate thick: ",Plate[2])); | |
| //- Select flashlight data from table | |
| echo(str("Flashlight: ",FlashName)); | |
| FlashIndex = search([FlashName],LightBodies,1,0)[F_NAME]; | |
| //- Set ball dimensions | |
| BallWall = 5.0; // max ball wall thickness | |
| echo(str("Ball wall: ",BallWall)); | |
| BallOD = IntegerMultiple(LightBodies[FlashIndex][F_GRIPOD] + 2*BallWall,1.0); | |
| echo(str(" OD: ",BallOD)); | |
| BallLength = IntegerMultiple(min(sqrt(pow(BallOD,2) – pow(LightBodies[FlashIndex][F_GRIPOD],2)) – 2*4*ThreadThick, | |
| LightBodies[FlashIndex][F_GRIPLEN]),1.0); | |
| echo(str(" length: ",BallLength)); | |
| BallSides = 8*4; | |
| //- Set clamp ring dimensions | |
| ClampOD = 50; | |
| echo(str("Clamp OD: ",ClampOD)); | |
| ClampLength = min(20.0,0.75*BallLength); | |
| echo(str(" length: ",ClampLength)); | |
| ClampScrewOC = IntegerMultiple((ClampOD + BallOD)/2,1); | |
| echo(str(" screw OC: ",ClampScrewOC)); | |
| TiltMirror = (Side == "Right") ? [0,0,0] : [0,1,0]; | |
| //- 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); | |
| } | |
| //- Fairing Bracket | |
| // This part of the fairing mount supports the whole flashlight mount | |
| // Centered on screw hole | |
| module Bracket() { | |
| linear_extrude(height=Bracket[2],convexity=2) | |
| difference() { | |
| translate([(Bracket[0]/2 – BracketHoleOffset),0,0]) | |
| offset(delta=ThreadWidth) | |
| intersection() { | |
| square([Bracket[0],Bracket[1]],center=true); | |
| union() { | |
| for (i=[-1,0,1]) // middle circle fills gap | |
| translate([i*(Bracket[0]/2 – BracketR),0]) | |
| circle(r=BracketR); | |
| } | |
| } | |
| circle(d=BracketHoleOD/cos(180/8),$fn=8); // dead center at the origin | |
| } | |
| } | |
| //- General plate shape | |
| // Centered on the hole for the fairing bracket | |
| module PlateBlank() { | |
| difference() { | |
| translate([BracketHoleOC,0,0]) | |
| intersection() { | |
| translate([0,0,Plate[2]/2]) // select upper half of spheres | |
| cube(Plate,center=true); | |
| hull() | |
| if (RoundEnds) | |
| for (i=[-1,1]) | |
| translate([i*(Plate[0]/2 – PlateRad),0,0]) | |
| resize([Plate[1]/2,Plate[1],2*Plate[2]]) | |
| sphere(r=PlateRad); // nice round ends! | |
| else | |
| for (i=[-1,1], j=[-1,1]) | |
| translate([i*(Plate[0]/2 – PlateRad),j*(Plate[1]/2 – PlateRad),0]) | |
| resize([2*PlateRad,2*PlateRad,2*Plate[2]]) | |
| sphere(r=PlateRad); // nice round corners! | |
| } | |
| translate([2*BracketHoleOC,0,-Protrusion]) // punch screw holes | |
| PolyCyl(BracketHoleOD,2*Plate[2],8); | |
| translate([0,0,-Protrusion]) | |
| PolyCyl(BracketHoleOD,2*Plate[2],8); | |
| } | |
| } | |
| //- Inner plate | |
| module InnerPlate() { | |
| difference() { | |
| PlateBlank(); | |
| translate([0,0,Plate[2] – Bracket[2] + Protrusion]) // punch fairing bracket | |
| Bracket(); | |
| } | |
| } | |
| //- Slotted ball around flashlight | |
| // Print with brim to ensure adhesion! | |
| module SlotBall() { | |
| NumSlots = 8*2; // must be even, half cut from each end | |
| SlotWidth = 2*ThreadWidth; | |
| SlotBaseThick = 10*ThreadThick; // enough to hold finger ends together | |
| RibLength = (BallOD – LightBodies[FlashIndex][F_GRIPOD])/2; | |
| translate([0,0,(Layout == "Build") ? BallLength/2 : 0]) | |
| rotate([0,(Layout == "Show") ? 90 : 0,0]) | |
| difference() { | |
| intersection() { | |
| sphere(d=BallOD,$fn=2*BallSides); // basic ball | |
| cube([2*BallOD,2*BallOD,BallLength],center=true); // trim to length | |
| } | |
| translate([0,0,-LightBodies[FlashIndex][F_GRIPOD]]) | |
| rotate(180/BallSides) | |
| PolyCyl(LightBodies[FlashIndex][F_GRIPOD],2*BallOD,BallSides); // remove flashlight body | |
| for (i=[0:NumSlots/2 – 1]) { // cut slots | |
| a=i*(2*360/NumSlots); | |
| SlotCutterLength = LightBodies[FlashIndex][F_GRIPOD]; | |
| rotate(a) | |
| translate([SlotCutterLength/2,0,SlotBaseThick]) | |
| cube([SlotCutterLength,SlotWidth,BallLength],center=true); | |
| rotate(a + 360/NumSlots) | |
| translate([SlotCutterLength/2,0,-SlotBaseThick]) | |
| cube([SlotCutterLength,SlotWidth,BallLength],center=true); | |
| } | |
| } | |
| color("Yellow") | |
| if (Support && (Layout == "Build")) { | |
| for (i=[0:NumSlots-1]) { | |
| a = i*360/NumSlots; | |
| rotate(a + 180/NumSlots) | |
| translate([(LightBodies[FlashIndex][F_GRIPOD] + RibLength)/2 + ThreadWidth,0,BallLength/(2*4)]) | |
| cube([RibLength,2*ThreadWidth,BallLength/4],center=true); | |
| } | |
| } | |
| } | |
| //- Clamp around flashlight ball | |
| module BallClamp(Section="All") { | |
| BossLength = ClampScrew[LENGTH] – 1*ClampScrewWasher[LENGTH]; | |
| BossOD = ClampInsert[OD] + 2*(6*ThreadWidth); | |
| difference() { | |
| union() { | |
| intersection() { | |
| sphere(d=ClampOD,$fn=BallSides); // exterior ball clamp | |
| cube([ClampLength,2*ClampOD,2*ClampOD],center=true); // aiming allowance | |
| } | |
| hull() | |
| for (j=[-1,1]) | |
| translate([0,j*ClampScrewOC/2,-BossLength/2]) | |
| cylinder(d=BossOD,h=BossLength,$fn=6); | |
| } | |
| sphere(d=(BallOD + 1*ThreadThick),$fn=BallSides); // interior ball with minimal clearance | |
| for (j=[-1,1]) { | |
| translate([0,j*ClampScrewOC/2,-ClampOD]) // screw clearance | |
| PolyCyl(ClampScrew[ID],2*ClampOD,6); | |
| translate([0,j*ClampScrewOC/2, // insert clearance | |
| -(BossLength/2 – ClampInsert[LENGTH] – 3*ThreadThick)]) | |
| rotate([0,180,0]) | |
| PolyCyl(ClampInsert[OD],2*ClampOD,6); | |
| translate([0,j*ClampScrewOC/2, // insert transition | |
| -(BossLength/2 – ClampInsert[LENGTH] – 3*ThreadThick)]) | |
| cylinder(d1=ClampInsert[OD]/cos(180/6),d2=ClampScrew[ID],h=6*ThreadThick,$fn=6); | |
| } | |
| if (Section == "Top") | |
| translate([0,0,-ClampOD/2]) | |
| cube([2*ClampOD,2*ClampOD,ClampOD],center=true); | |
| else if (Section == "Bottom") | |
| translate([0,0,ClampOD/2]) | |
| cube([2*ClampOD,2*ClampOD,ClampOD],center=true); | |
| } | |
| color("Yellow") | |
| if (Support) { // ad-hoc supports | |
| NumRibs = 6; | |
| RibLength = 0.5 * BallOD; | |
| RibWidth = 1.9*ThreadWidth; | |
| SupportOC = ClampLength / NumRibs; | |
| if (Section == "Top") // base plate for adhesion | |
| translate([0,0,ThreadThick]) | |
| cube([ClampLength + 6*ThreadWidth,RibLength,2*ThreadThick],center=true); | |
| else if (Section == "Bottom") | |
| translate([0,0,-ThreadThick]) | |
| cube([ClampLength + 6*ThreadWidth,RibLength,2*ThreadThick],center=true); | |
| render(convexity=2*NumRibs) | |
| intersection() { | |
| sphere(d=BallOD – 0*ThreadWidth); // cut at inner sphere OD | |
| cube([ClampLength + 2*ThreadWidth,RibLength,BallOD],center=true); | |
| if (Section == "Top") // select only desired section | |
| translate([0,0,ClampOD/2]) | |
| cube([2*ClampOD,2*ClampOD,ClampOD],center=true); | |
| else if (Section == "Bottom") | |
| translate([0,0,-ClampOD/2]) | |
| cube([2*ClampOD,2*ClampOD,ClampOD],center=true); | |
| union() { // ribs for E-Z build | |
| for (j=[-1,0,1]) | |
| translate([0,j*SupportOC,0]) | |
| cube([ClampLength,RibWidth,1.0*BallOD],center=true); | |
| for (i=[0:NumRibs]) // allow NumRibs + 1 to fill the far end | |
| translate([i*SupportOC – ClampLength/2,0,0]) | |
| rotate([0,90,0]) | |
| cylinder(d=BallOD – 2*ThreadThick, | |
| h=RibWidth,$fn=BallSides,center=true); | |
| } | |
| } | |
| } | |
| } | |
| //- Mount between fairing plate and flashlight ball | |
| // Build with support for bottom of clamp screws! | |
| module Mount() { | |
| TextRotate = (Side == "Right") ? 0 : 180; | |
| MountShift = [ClampOD*sin(ToeIn/2), | |
| 0, | |
| ClampOD/2]; | |
| difference() { | |
| translate([-BracketHoleOC,0,0]) // put bracket center at origin | |
| PlateBlank(); | |
| mirror([0,1,0]) | |
| translate([0,0,-Protrusion]) | |
| linear_extrude(height=3*ThreadThick + Protrusion) { | |
| translate([BracketHoleOC + 15,0,0]) | |
| text(text=">>>",size=5,spacing=1.20,font="Arial",halign="center",valign="center"); | |
| translate([-BracketHoleOC,8,0]) rotate(TextRotate) | |
| text(text=str("Toe ",ToeIn),size=5,spacing=1.20,font="Arial",halign="center",valign="center"); | |
| translate([-BracketHoleOC,-8,0]) rotate(TextRotate) | |
| text(text=str("Tilt ",Tilt),size=5,spacing=1.20,font="Arial",halign="center",valign="center"); | |
| translate([BracketHoleOC,-8,0]) rotate(TextRotate) | |
| text(text=Side,size=5,spacing=1.20,font="Arial",halign="center",valign="center"); | |
| translate([BracketHoleOC,8,0]) rotate(TextRotate) | |
| text(text=str("Roll ",Roll),size=5,spacing=1.20,font="Arial",halign="center",valign="center"); | |
| translate([-(BracketHoleOC + 15),0,0]) | |
| rotate(90) | |
| text(text="KE4ZNU",size=4,spacing=1.20,font="Arial",halign="center",valign="center"); | |
| } | |
| } | |
| mirror(TiltMirror) { | |
| translate(MountShift) | |
| rotate([-Roll,ToeIn,Tilt]) | |
| BallClamp("Bottom"); | |
| color("Yellow") | |
| if (MountSupport) { // anchor outer corners at worst overhang | |
| RibWidth = 1.9*ThreadWidth; | |
| SupportOC = 0.1 * ClampLength; | |
| difference() { | |
| rotate([0,0,Tilt]) | |
| translate([(ClampOD – BallOD)*sin(ToeIn/2),0,0]) | |
| for (i=[-4.5,-2.5,0,2.0,4.5]) | |
| translate([i*SupportOC – 0.0,0,(5 + Plate[2])/2]) | |
| cube([RibWidth,0.7*ClampOD,(5 + Plate[2])],center=true); | |
| translate(MountShift) | |
| rotate([-Roll,ToeIn,Tilt]) | |
| sphere(d=ClampOD – 2*ThreadWidth,$fn=BallSides); | |
| } | |
| } | |
| } | |
| } | |
| //- Build things | |
| if (Component == "Bracket") | |
| Bracket(); | |
| if (Component == "Ball") | |
| SlotBall(); | |
| if (Component == "BallClamp") | |
| if (Layout == "Show") | |
| BallClamp("All"); | |
| else if (Layout == "Build") | |
| BallClamp("Top"); | |
| if (Component == "Mount") | |
| Mount(); | |
| if (Component == "Plates") { | |
| translate([0,0.7*Plate[1],0]) | |
| InnerPlate(); | |
| translate([0,-0.7*Plate[1],0]) | |
| PlateBlank(); | |
| } | |
| if (Component == "Complete") { | |
| translate([-BracketHoleOC,0,0]) | |
| PlateBlank(); | |
| mirror(TiltMirror) { | |
| translate([0,0,ClampOD/2]) { | |
| rotate([-Roll,ToeIn,Tilt]) | |
| SlotBall(); | |
| rotate([-Roll,ToeIn,Tilt]) | |
| BallClamp(); | |
| } | |
| } | |
| } |
Although I wish I could come up with a finished design in one pass, usually I end up with a big pile of nope before producing the one I want:
The mounts on the left show the progression from large hemisphere balls to the same-size finger ball to the smaller finger ball, with the smaller cyan arch clamp in the foreground still festooned with its support structure. The stack of plates to the right (with the original faded & distintegrating ABS plates in the bag) comes from reprinting in cyan to match the small mounts now on the bikes:
Hey, it’s time for a ride!
The Smell of Molten Projects in the Morning 