Une Pièce De Déodorant 900 Care

Table of Contents

the problem
what the internet says about it
analysis of the geometry
the platform
the threaded rod
the printable model
what remains to be done
Permalink

the problem

I want to print a replacement for this piece of my 900.care refillable deodorant: the piston that pushes the stick up.

what the internet says about it

Not much, unfortunately. I could not find any teardown, spare part or printable replacement for this piece: the searches on cults3d, thingiverse and printables all came out empty, and 900.care only sells the whole case with the refills on their product page (where we also learn that a refill weighs 63 g).

Still, the blog of 900.care confirms what the piece does:

“Il vous suffit de clipser ensuite la recharge sur le déo (en suivant tout bêtement les flèches)”: the refill clips onto this piece, which is what the snap fits at the base of the rod are for,
“Tournez la molette”: the stick is raised by turning the wheel at the bottom of the case, so the wheel holds a nut and the rod is a lead screw (the standard twist-up architecture, also described in the By Humankind refillable dispenser patent). The oval platform, keyed in the oval case, keeps the rod from spinning. So its ribs are a fine-pitch helical thread, not rings: a nut has nothing to push against on concentric rings.

analysis of the geometry

Taking a look at the piece, we can see that it’s basically:

an oval (stadium shaped) platform, with two small vent holes,
a long ribbed rod centered on it,
and, around the base of the rod, two curved snap fits facing each other along the long axis, onto which the cup of the refill most likely clips, plus two thin radial pins on the short axis.

Measuring it gives roughly a 55x30x12 platform,

and a 58 long rod of diameter 8, with closely spaced ribs.

the platform

Let’s get started with the platform. Here are its dimensions.

base_length = 55
base_width = 30
base_height = 12
base_fillet = 14

It’s a box whose vertical edges are filleted with a radius slightly smaller than half its width, to get the stadium shape.

platform_workplane = cq.Workplane("XY")

platform = (
    platform_workplane
    .box(base_length, base_width, base_height, centered=(True, True, False))
    .edges("|Z")
    .fillet(base_fillet)
)

Then I cut the two vent holes on each side of the center.

vent_hole_radius = 1
vent_hole_offset = 15

def vent_hole(direction=1):
    return (
        cq.Workplane("XY", origin=(direction * vent_hole_offset, 0, 0))
        .cylinder(3 * base_height, vent_hole_radius)
    )

with_vent_holes = platform.composecut(
    vent_hole(direction=1).union(vent_hole(direction=-1))
)

the threaded rod

The rod looks like a stack of closely spaced ribs, but since it is a lead screw they have to be a helical thread. Counting crests against the ruler in the photos gives 12 over 30 mm, so a lead of 2.5; the handedness (and whether it is single start) still has to be checked against the molette.

rod_length = 58
rod_radius = 4
thread_depth = 0.8
thread_lead = 2.5
left_handed = False

I sweep a triangular profile along a helix around a thin core. The profile base starts slightly inside the core so the union is watertight.

rod_workplane = cq.Workplane("XY", origin=(0, 0, base_height))

core_radius = rod_radius - thread_depth
rod = rod_workplane.cylinder(
    rod_length, core_radius, centered=(True, True, False)
)

helix = cq.Wire.makeHelix(
    thread_lead,
    rod_length - thread_lead,
    core_radius,
    center=cq.Vector(0, 0, base_height + thread_lead / 2),
    lefthand=left_handed,
)
thread = (
    cq.Workplane("XZ", origin=(core_radius, 0, base_height + thread_lead / 2))
    .moveTo(-0.2, -thread_lead / 4)
    .lineTo(thread_depth, 0)
    .lineTo(-0.2, thread_lead / 4)
    .close()
    .sweep(cq.Workplane(obj=helix), isFrenet=True)
)
rod = rod.union(thread)

with_rod = with_vent_holes.composeunion(rod)

Then let’s look at the base of the rod. Since the refill clips onto this piece, the two curved tabs are cantilever snap hooks: walls concentric with the rod, topped by a head that overhangs outwards with an insertion chamfer on top, a short crest, and a flat underside forming the retention ledge. The cup of the refill slides down along the chamfer, the fingers flex inwards, and the rim clicks under the ledge. They stand away from the rod, leaving them room to flex. The two radial pins are not hooks: they most likely key the cup angularly. There is also a small round hub hugging the base of the rod, that I model as a plain cylinder, small enough to stay clear of the fingers.

hub_radius = 5
hub_height = 2
snap_offset = 5.5           # inner face of the finger, from the axis
snap_thickness = 1.5        # thickness of the flexing wall
snap_width = 9              # tangential width (chord) of the finger
snap_straight_height = 3    # straight wall, up to the retention ledge
snap_crest_height = 5.5     # top of the crest
snap_height = 7             # total height, at the tip of the chamfer
snap_bump_depth = 1.2       # how much the head overhangs
pin_length = 7              # radial reach of the keying pins
pin_width = 1
pin_height = 3.5

I draw the hook profile in a vertical plane, revolve it around the rod axis and keep a chord-wide slice of the ring to get one curved finger. The pins are plain boxes.

def snap_finger(angle):
    ring = (
        cq.Workplane("XZ", origin=(0, 0, base_height))
        .moveTo(snap_offset, 0)
        .lineTo(snap_offset + snap_thickness, 0)
        .lineTo(snap_offset + snap_thickness, snap_straight_height)
        .lineTo(snap_offset + snap_thickness + snap_bump_depth, snap_straight_height)
        .lineTo(snap_offset + snap_thickness + snap_bump_depth, snap_crest_height)
        .lineTo(snap_offset + snap_thickness, snap_height)
        .lineTo(snap_offset, snap_height)
        .close()
        .revolve(360, (0, 0), (0, 1))
    )
    return ring.intersect(
        cq.Workplane("XY", origin=(0, 0, base_height))
        .box(2 * snap_offset, snap_width, 2 * snap_height,
             centered=(False, True, False))
        .rotate((0, 0, 0), (0, 0, 1), angle)
    )

def pin(angle):
    return (
        cq.Workplane("XY", origin=(0, 0, base_height))
        .box(pin_length, pin_width, pin_height,
             centered=(False, True, False))
        .rotate((0, 0, 0), (0, 0, 1), angle)
    )

snaps = (
    cq.Workplane("XY", origin=(0, 0, base_height))
    .cylinder(hub_height, hub_radius, centered=(True, True, False))
)
for angle in (0, 180):
    snaps = snaps.union(snap_finger(angle))
for angle in (90, 270):
    snaps = snaps.union(pin(angle))

with_snaps = with_rod.composeunion(snaps)

the printable model

The last thing to do is to assemble the whole thing into a shinny STL file that I can feed to my printer.

what remains to be done

measure the lead precisely (the travel of one full molette turn) and the thread depth, and check the handedness,
take a closer look at the hub under the platform and model it,
check the snap fingers dimensions against the cup of a refill, since that is what clips onto them,
print a small test slice of the rod to validate the fit in the ratchet ring before printing the whole piece.