Thoughts on hooks

[amatulic]

I've been thinking about a possible new file hook-n-ring.scad (or some similar name) that the code in #1687 could be merged into.

It occurs to me that there's a fairly large class of 2D wire hooks and 2D ribbon hooks, both of which are made by extruding a 2D profile upward, or sweeping a cross-section along a 2D path.

Here are some thoughts I sketched about the different common hook profiles. The hook itself could be on either end of the wire, and can be configured with a single bend or double bend (not counting the bend from centering the hook with respect to the "body"), and the bend can be enough to close the hook into a loop.

I have a "ribbon" hook on the door of a closet. The hook is just on one end, and a hole for fastening is on the other end. A bit thicker and plastic would work fine for this.

I've already written the code for the cross section of the "wire" or "ribbon". It respects $fn, $fa, and $fs. Radius of the rounding self-adjusts depending on the width and height, maintaining a 40° angle from the build plate.

include <BOSL2/std.scad>

function wire_hook_profile(width, height, overhang=40) =
    let(
        r = min(width/2, height/(2*cos(overhang))),
        curvht = r*cos(overhang),
        rxoff = max(0, width/2-r),
        ryoff = max(0, height/2-curvht),
        astep = $fn ? (358-4*overhang)/$fn : min($fa, (180/PI) * $fs/r)
    ) let(astop = 90-overhang) [
        for(a=[0:-astep:0.001-astop]) [r*cos(a)+rxoff, r*sin(a)-ryoff],
        [r*cos(-astop)+rxoff, r*sin(-astop)-ryoff],
        for(a=[180+astop:-astep:180.001]) [r*cos(a)-rxoff, r*sin(a)-ryoff],
        [-r-rxoff,-ryoff],
        for(a=[180:-astep:180.001-astop]) [r*cos(a)-rxoff, r*sin(a)+ryoff],
        [-r*cos(astop)-rxoff, r*sin(astop)+ryoff],
        for(a=[astop:-astep:0.001]) [r*cos(a)+rxoff, r*sin(a)+ryoff],
        [r+rxoff, ryoff]
];

polygon(points=wire_hook_profile(10, 5, $fa=5));
left(9) polygon(points=wire_hook_profile(5, 10, $fa=5));
right(11) polygon(points=wire_hook_profile(10, 10, $fa=5));

That code produces these three example profiles:

I was wondering what the API for wire hooks would look like. I envision two modules:

• One that takes dimensions for inner radius (outer not needed) of the bends, the length of the extension on the end of the hook, the bend direction, and the type of hook on each end.
• One that takes a path and applies rounding to each vertex as appropriate, possibly different for each edge.

[adrianVmariano]

Have you looked on printables to see if anybody has posted any hooks that we haven't thought of?

I wonder about the idea of a mixed ribbon - wire hook form where you have a ribbon side to screw on to something and a wire side to hold something with a small hole.

[amatulic]

There are many hook configurations. I just wanted to start out with a basic class of 2D hooks because they are versatile and easy to print. I thought a general-purpose module (or two) would cover most of the use cases for this class of hooks. They can be made into wall hooks, shelf hooks, coat hooks, door hooks, towel hooks, etc. This hook library on Thingiverse is way more complicated than it needs to be, with many different dimensions defined (mostly to accommodate spacing between screws and features of the hook), as you can see by scrolling through the images. If you get a Google vignette, just hit your back button and go forward again.

Printables and Thingiverse have lots of different kinds of hooks, especially caribiners, which I think we should avoid unless we can come up with a superior design. I saw YouTube videos testing the strength of these, and they almost always fail at the latch, even when the latch is trapped with a collar. This surprised me because I expected the hinge to shear first, if the design included a hinge for the latch (some of them just flex).

[adrianVmariano]

I took a look at the hook library. I agree that all the stuff about screws is extra. We should provide a few anchors and users can position mounting holes using those as needed.

The one interesting feature that code shows is the thickened bottom area with hole to strengthen the hook.

Regarding the interface, so we have two hook ends. It seems like the hook top (mounting) options are flat, to be mounted to something, what that code calls (square) "bracket", and then rounded "bracket" which could also have a circle that comes around more than 180 deg so it snaps onto a rod. The last option is to have no mounting at all---the hook is attached directly to some other part of the model. I think there are basically two ways to do the API here. One is the direct way, so we have top="flat" and then top_length= and if you select top="bracket" (or whatever better name) then you have top_height and also bracket_width? Whatever parameters you need.

The other API option is to do like offset_sweep and have parameters come in using a structure and have helper functions to make the structure. It seems like laying out a list of what the minimal parameter set looks like is a good way to get an idea if this helper function idea makes sense or not. One reason I did it that way is because I had two ends that needed the same interface and quite a lot of parameters and I wanted a way you could specify the ends to be the same, for example.

Are hooks symmetric from to to bottom? Or is the bottom different than the top?

[dan-p3rry]

There's also a clothes-hanger style hook. This is from a model I did 18 months ago to hang from a shower head arm.

[amatulic]

I think a hook API could give a choice of hook shapes for either end. There are times when you'd want a round hook on both ends, or a square-ish hook on both ends, or a pegboard-like hook on the top, or a hook or loop only on one end.

As I indicated with my sketch above, there seems to be two basic types: single bend and double bend, with an extra bend if the hook is centered on the shaft, like dan-p3rry's coat hanger hook above.

Thickening the bottom to strengthen the hook is pointless if you don't also strengthen the top, which experiences the same force in the other direction and is subject to similar bending loads.

[adrianVmariano]

No, if you screw the hook to a wall, or mount it directly in your model (especially the latter because it enormously increases the mounting area) then strengthening the bottom of the hook will make a big difference.

If you think a symmetric API makes sense that may suggest the helper-function with structures API approach as a better method. Another advantage of that scheme is that it's pretty easy to expand it to include other geometries if someone comes up with them.

As far as I can tell, @dan-p3rry's hook fits into the framework of the original post, being a circular hook that is centered. Isn't that the case?

[RAMilewski]

This still needs to be made attachable. And for reasons I don't understand I had to add the includes in the examples to get the images to come out locally in openscad-docsgen.

// Module: s_hook()
// Synopsis: Creates an S-hook
// SynTags: Geom
// Topics: Shapes (3D), Hooks, VNF Generators
// See Also: d_ring()
// Usage: As Module
//   s_hook(or, sides, ....);
// Description:
//   Creates an S-hook with specified cross-section shape and size. 
//   Optional straight segments and reverse curls can be added to each end of the hook.   
// Arguments:
//   or = the outside radius of the cross-section shape. Default: 3
//   sides = the number of sides of the cross-section shape, values less than 3 result in a circular cross-section. Default: 6
//   l_shaft = length of the shaft, the straight section that passes through the origin. Default: 25.
//   ---
//   r_loop1 = radius of the loop at the +Y end of the hook. Default: 5
//   angle1 = end angle in degrees of loop1.  Default: 180
//   l_stem1 = length of the straight segment at the end of loop1. Default: 0
//   r_curl1 = radius of the curl at the +Y end of the hook.  Default: 0 
//   angle_curl1 = end angle in degrees of the curl at the +Y end of the hook. Default: 0
//   r_loop2 = radius of the loop at the -Y end of the hook. Default:5
//   angle2 = end angle in degrees of loop2. Default: 180
//   l_stem2 = length of the straight segment at the end of loop2. Default: 0
//   r_curl2 = radius of the curl at the -Y end of the hook.  Default: 0 
//   angle_curl2 = end angle in degrees of the curl at the -Y end of the hook. Default: 0
//   .
// Example(3D): only default values
//   include<BOSL2/std.scad>
//   include<hooks.scad>
//   s_hook();
// Example(3D): s_hook with circular cross section
//   include<BOSL2/std.scad>
//   include<hooks.scad>
//   s_hook(sides = 0);
// Example(3D): Longer shaft
//   include<BOSL2/std.scad>
//   include<hooks.scad>
//   s_hook(l_shaft = 50);
// Example(3D): Larger loop on +Y end
//   include<BOSL2/std.scad>
//   include<hooks.scad>
//   s_hook(r_loop1 = 12);
// Example(3D): Added stem on +Y end
//   include<BOSL2/std.scad>
//   include<hooks.scad>
//   s_hook(l_stem1 = 5);
// Example(3D): Stem and curl on -Y end
//   include<BOSL2/std.scad>
//   include<hooks.scad>
//   s_hook(l_stem2 = 4, r_curl2 = 5, angle_curl2 = 70);
// Example(3D): Longer arc on +Y end.
//   include<BOSL2/std.scad>
//   include<hooks.scad>
//   s_hook(sides = 0, angle1 = 230, l_stem1 = 3, r_curl1 = 3, angle_curl1 = 90);


module s_hook(or = 2, sides = 6, l_shaft = 25, $fn = 32,
    r_loop1 = 5, angle1 = 180, l_stem1 = 0, r_curl1 = 0,  angle_curl1 = 0,
    r_loop2 = 5, angle2 = 180, l_stem2 = 0, r_curl2 = 0,  angle_curl2 = 0) {

    assert(l_shaft>0,  "l_shaft must be > 0");
    assert(is_int(sides), "Number of sides must be an integer.");

    stem1 = l_stem1 <= 0 ? 1e-10 : l_stem1;
    stem2 = l_stem2 <= 0 ? 1e-10 : l_stem2;

    shape = sides > 2 ? regular_ngon(sides, or, align_side = FWD) : circle(or);     

    path1 = turtle(["setdir", 90, "ymove",l_shaft/2, "arcleft",r_loop1,angle1, "move",stem1, "arcright",r_curl1,angle_curl1]);
    path_sweep(shape,path1);
    path2 = turtle(["setdir", -90, "ymove",-l_shaft/2, "arcleft",r_loop2,angle2, "move",stem2, "arcright",r_curl2,angle_curl2]);
    path_sweep(shape,path2);
  
    endcap = right_half(shape);
    move(path1[len(path1)-1]) rotate_sweep(endcap);
    move(path2[len(path2)-1]) rotate_sweep(endcap);

}