Des Pieds D'une Table D'enfant

contexte

La table mesure 360 mm du sol en dessous du plateau — trop basse pour être utilisée avec une chaise. L’objectif est de porter cette hauteur à 420 mm (+60 mm) en ajoutant un manchon imprimé en 3D sur chaque pied, sans modifier la table elle-même.

Les pieds ont la forme d’un pavé de section 15×80 mm prolongé par un demi-cylindre de rayon 40 mm ; ils sont inclinés de 21° par rapport à la verticale. Le demi-cylindre repose sur le sol, le point de contact se trouvant à 33 mm du bord extérieur. Le plateau fait 15 mm d’épaisseur. Particularité de cette table : les deux côtés ne sont pas symétriques en hauteur — un pied repose au sol, l’autre est suspendu à 28 mm.

angle_deg = 21        # angle des pieds par rapport à la verticale (mesuré)
foot_gap = 28         # distance pied suspendu / sol dans la config d'origine (mm)
current_height = 360  # hauteur actuelle mesurée (sol en dessous du plateau)
target_height = 420   # hauteur cible (mm)

Vue de profil, l’asymétrie saute aux yeux : un pied touche le sol, l’autre flotte à foot_gap millimètres au-dessus. Les deux pieds sont parallèles, penchés vers l’intérieur de l’angle angle_deg ; le plateau les relie en haut à la hauteur current_height.

profil du demi-cylindre

Le demi-cylindre apparaît avec le même rayon sur trois pièces : le pied lui-même, la cavité d’emboîtement du manchon (majorée du jeu), et le corps extérieur du manchon. On décrit donc son profil une seule fois, sous forme de fonction qui retourne un sketch — la structure en fonction impose un détour côté build123d, détaillé en annexe.

def profil_demi_cylindre(rayon):
    with BuildSketch(Plane.XZ) as sk:
        with BuildLine():
            RadiusArc((-rayon, 0), (rayon, 0), -rayon)
            Line((rayon, 0), (-rayon, 0))
        make_face()
    return sk

Le motif extrude(profil_demi_cylindre(R).sketch, amount=e/2, both=True) revient dans les trois solides qui accueillent un demi-cylindre. L’argument both=True étend le profil de part et d’autre de Y=0, donnant un demi-cylindre d’épaisseur totale e collé à l’extrémité du pavé.

modèle d’un pied

Le pied est un pavé de section 15×80 mm prolongé par un demi-cylindre de rayon 40 mm. C’est la géométrie de référence : la cavité d’emboîtement du manchon reprendra la même forme, majorée du jeu.

thickness   = 15   # mm, épaisseur du pavé
width       = 80   # mm, largeur du pavé
R           = 40   # mm, rayon du demi-cylindre
pave_length = 343  # mm, longueur arbitraire

with BuildPart() as pied:
    Box(width, thickness, pave_length,
        align=(Align.CENTER, Align.CENTER, Align.MIN))
    extrude(profil_demi_cylindre(R).sketch, amount=thickness / 2, both=True)

Avant d’aller plus loin dans la construction du manchon, on valide la géométrie du pied en l’exportant en STL et en l’inspectant visuellement. C’est le moment où les erreurs d’arc ou de proportions sont détectées au plus tôt.

manchon pour le grand pied

Le grand pied touche le sol et donne la hauteur actuelle H=360mm. Ce manchon l’allonge de 60mm verticaux pour atteindre H=420mm.

Trois constantes caractérisent l’emboîtement : le jeu, l’épaisseur de paroi, et la profondeur d’insertion.

Le jeu (clearance) est la marge laissée par côté entre le pied et la cavité d’emboîtement. Une buse de 0.8 mm donne une précision dimensionnelle de ±0.2–0.3 mm¹ : trop faible, l’emboîtement serre ou bloque ; trop large, le pied tient mal. Les tableaux FDM proposent des valeurs typiques par classe d’ajustement², mais la cote retenue reste à ajuster par essai.

L’épaisseur de paroi (wall) se cale dans la tranche haute de la plage recommandée en FDM pour une pièce structurelle³, ce qui garantit la rigidité sans nécessiter de renforts internes avec une buse 0.8 mm : à ~0.9 mm de largeur d’extrusion⁴, la cote retenue représente plusieurs périmètres pleins — au-delà des deux périmètres minimum qu’implique la règle « paroi ≥ 2 × diamètre de buse »⁵.

La profondeur d’insertion (insertion_depth) est la longueur sur laquelle le pied s’engage au-dessus du demi-cylindre. Valeur choisie arbitrairement : suffisante à l’œil pour résister au basculement sur un pied incliné, tout en restant sur la portion utile du pied — à ajuster par essai si l’emboîtement réel s’avère trop lâche.

clearance = 0.3       # jeu d'emboîtement par côté (mm)
wall = 3.0            # épaisseur paroi du manchon (mm)
insertion_depth = 40  # profondeur d'insertion du pied au-dessus du demi-cylindre (mm)

Les trois cotes se lisent d’un coup sur une coupe latérale du manchon enfilé sur le pied.

Les dimensions de jeu et de paroi forment un contrat : le jeu doit être assez grand pour que le pied s’engage sans serrage, mais la paroi doit rester suffisante (au moins quelques millimètres) pour que le manchon soit rigide. Les cotes qui en découlent — cavité intérieure, manchon extérieur — se lisent d’un coup d’œil sous forme chiffrée.

jeu    : 0.5 mm/côté
paroi  : 3.0 mm
cavité          : 81.0×16.0 mm, R 40.5 mm
manchon externe : 87.0×22.0 mm, R 43.5 mm

À ces paramètres communs s’ajoute la rehausse propre au grand pied : les 60 mm verticaux qui amènent la table de sa hauteur actuelle à la hauteur cible.

target_raise = target_height - current_height

La cavité d’emboîtement doit être exactement la forme du pied majorée du jeu. Il faut qu’elle soit strictement plus grande que le pied (sinon le pied ne rentre pas) et strictement plus petite que la carcasse externe du manchon (sinon il ne reste pas de paroi).

pied < cavité < manchon — encadrement ok

with BuildPart() as cavity_part:
    Box(cavity_width, cavity_thickness, insertion_depth,
        align=(Align.CENTER, Align.CENTER, Align.MIN))
    extrude(profil_demi_cylindre(cavity_R).sketch, amount=cavity_thickness / 2, both=True)

La carcasse externe enveloppe la cavité de la paroi wall. Sa longueur axiale somme l’insertion du pied et une extension qui produit la rehausse : le pied étant incliné à 21°, une rehausse verticale de target_raise demande une extension axiale target_raise / cos(21°).

cavity_width = width + 2 * clearance
cavity_thickness = thickness + 2 * clearance
cavity_R = R + clearance
manchon_width = width + 2 * (wall + clearance)
manchon_thickness = thickness + 2 * (wall + clearance)
manchon_R = manchon_width / 2
extension_length = target_raise / math.cos(math.radians(angle_deg))
manchon_length = insertion_depth + extension_length

La cavité vient d’être construite à l’origine de son repère local : son pavé occupe z ∈ [0, insertion_depth], et le demi-cylindre descend en-dessous de z = 0. Or le pied entre dans le manchon par le haut ; il faut donc remonter la cavité pour que le sommet de son pavé coïncide avec le sommet du manchon, situé à z = manchon_length. Le décalage vaut donc manchon_length − insertion_depth : après translation, le pavé affleure l’ouverture haute et le demi-cylindre plonge à l’intérieur du manchon, là où viendra se loger celui du pied. Un schéma en coupe latérale (plan XZ) matérialise cette opération — à gauche la cavité dans son repère local, à droite après translation dans la carcasse du manchon :

Une seconde coupe, vue depuis l’extérieur de la table avec le manchon posé incliné sur le sol, rend la relation extension_length × cos(21°) = target_raise visible : le sol est en bas, le sommet du pavé en haut ; la différence de hauteur entre les deux plans pointillés rouges et gris matérialise la rehausse.

On applique donc la translation manchon_length − insertion_depth calculée plus haut.

cavity_positioned = Pos(0, 0, manchon_length - insertion_depth) * cavity_part.part

La carcasse extérieure se construit alors autour de cette cavité. Les arêtes vives sont désagréables sous la main d’un enfant : on les arrondit d’un rayon perceptible au toucher sans fragiliser la paroi — sur les arêtes extérieures et la base du manchon.

with BuildPart() as manchon:
    Box(manchon_width, manchon_thickness, manchon_length,
        align=(Align.CENTER, Align.CENTER, Align.MIN))
    add(cavity_positioned, mode=Mode.SUBTRACT)
    extrude(profil_demi_cylindre(manchon_R).sketch, amount=manchon_thickness / 2, both=True)
    all_edges = manchon.part.edges()
    min_z = min(e.center().Z for e in all_edges)
    exterior_edges = [
        e for e in all_edges
        if (abs(abs(e.center().X) - manchon_width / 2) < 1
            and abs(abs(e.center().Y) - manchon_thickness / 2) < 1)
        or e.center().Z < min_z + 2
    ]
    fillet(exterior_edges, radius=1.5)

Voyons voir ça :

manchon pour le petit pied

Le petit pied est suspendu à 28mm du sol quand le grand pied repose à plat. Son manchon doit donc compenser ces 28mm en plus des 60mm de rehausse : la rehausse target_raise est majorée de foot_gap.

target_raise = target_height - current_height + foot_gap

assemblage complet

Avant d’envoyer un fichier à l’imprimante, on vérifie la cohérence de l’assemblage. Trois invariants tombent des cotes choisies : la hauteur cible — les pieds atteignent les 420 mm visés ; le niveau — la table repose d’aplomb sur ses quatre pieds ; la compensation asymétrique — l’écart foot_gap entre les deux côtés est absorbé par l’allongement axial du manchon petit.

hauteur cible, niveau, compensation asymétrique — invariants ok

Reste l’emboîtement manchon/pied — les faces de contact ne se lisent qu’en volume, pas aux chiffres. Une vue 3D avec les manchons rendus semi-transparents et les cavités colorées en orange opaque rend l’intérieur lisible sans impression réelle : on vérifie d’un coup d’œil que chaque pied s’engage dans sa cavité, que les hauteurs finales tombent pile, et que la cavité n’a pas été rongée accidentellement par une opération booléenne.

Les cotes de la table (écartement des pieds, longueur du plateau) déterminent le positionnement dans le repère monde.

table_width = 500     # mm, écartement centre-à-centre des pieds côté/côté (X, à mesurer)
plateau_length = 600  # mm, longueur du plateau (à mesurer)
foot_spacing = 450    # mm, écartement avant/arrière entre les deux pieds d'un même côté (Y, à mesurer)

Les cavités d’emboîtement apparaissent systématiquement en orange opaque — repère visuel pour qu’elles ressortent au milieu du bleu des manchons dans les trois vues.

formes de base

Tous les pieds ont la même forme : seules leur position et orientation dans le monde diffèrent. On construit donc cette forme une seule fois et on la réutilise.

Les pieds modélisés s’étendent théoriquement jusqu’au plateau et même au-delà. Or la pièce réelle s’arrête là où le bois commence — le pied ne traverse pas le plateau. Pour une soustraction robuste indépendante de l’angle ou de la position de chaque pied, on utilise une grande boîte positionnée juste sous le plateau, dont les dimensions XY et Z excèdent largement tout pied possible. Cette boîte est soustraite booléennement de chaque pied.

pave_length = target_height / math.cos(math.radians(angle_deg))

pied_shape = pied.part

cutting_box = Box(1000, 1000, 500, align=(Align.CENTER, Align.CENTER, Align.MIN))
cutting_box_positioned = Pos(0, 0, target_height) * cutting_box

Le côté droit de la table (X+) porte les grands pieds — ceux qui reposaient déjà au sol dans la configuration d’origine. Leur manchon les allonge de 60 mm verticaux pour atteindre les 420 mm cibles.

Positionner un pied incliné demande un pré-décalage vertical de R × cos(angle) pour que le point de contact retombe à Z=0 après rotation (annexe pour le détail).

Le pied lui-même est décalé dans son repère local de façon à ce que son extrémité inférieure soit exactement au fond de la cavité du manchon — la position qu’il occupera une fois imprimé et emboîté.

manchon_length_grand, insertion_depth_grand, angle_grand = manchon_length, insertion_depth, angle_deg
manchon_grand = manchon.part
cavity_grand = cavity_part.part
pied_grand = Pos(0, 0, manchon_length_grand - insertion_depth_grand) * pied_shape
lift_grand = manchon_R * math.cos(math.radians(angle_grand))
rotation_grand = Rot(0, -angle_grand, 0)

Le côté gauche (X−) porte le pied suspendu. Dans la configuration d’origine, ce pied était à 28 mm du sol quand l’autre reposait à plat. Son manchon doit donc compenser à la fois les 60 mm de rehausse commune et ces 28 mm supplémentaires — 88 mm au total. La rotation est la symétrique de celle du grand pied : inclinaison inverse.

Le plateau est la pièce de référence : c’est lui qui matérialise la hauteur cible. Il est posé avec son dessous à z = target_height — la face où les pieds viennent buter — et son dessus se retrouve à z = target_height + épaisseur.

plateau = Pos(0, 0, target_height) * Box(
    plateau_length, table_width + 40, thickness,
    align=(Align.CENTER, Align.CENTER, Align.MIN))
plateau.label = f"plateau (dessous à z={target_height}mm, hauteur cible)"
plateau.color = Color("wheat")

Les quatre pieds occupent des positions symétriques en X (grand/petit) et en Y (avant/arrière). On factorise le placement et le tronquage du pied par le plateau dans un helper appelé depuis la boucle.

def placed_pied(side, y):
    if side == "grand":
        world = Pos(table_width / 2, y, lift_grand) * rotation_grand
        pied, label, color = pied_grand, "grand pied (côté X+, reposait déjà au sol)", Color("peru")
    else:
        world = Pos(-table_width / 2, y, lift_petit) * rotation_petit
        pied, label, color = pied_petit, "petit pied (côté X−, suspendu à 28mm à l'origine)", Color("burlywood")
    coupe = (world * pied) - cutting_box_positioned
    coupe.label, coupe.color = label, color
    return world, coupe

repères de hauteur

Un assemblage qui a l’air correct peut masquer une erreur de quelques millimètres — et à 420 mm de haut, l’œil ne détecte pas un écart de 5 mm. On adjoint donc à l’assemblage des repères visuels chiffrés, tous top-alignés sur le dessous du plateau pour que la comparaison se fasse directement à l’œil.

Un plan horizontal translucide gris matérialise le sol réel à z = 0, là où reposent les manchons. Un second plan, rouge, se pose à z = target_height − current_height = 60 mm : c’est le niveau où arriverait la base du pied sans manchon, autrement dit l’altitude que la rehausse absorbe. Deux barres verticales plantées au centre de la table, entre les pieds, font office de règles graduées : la rouge, longue de 360 mm, va de z = 60 à z = 420 — c’est la hauteur que faisait l’ancienne table ; la verte, longue de 420 mm, descend jusqu’au vrai sol — c’est la hauteur qu’atteint la nouvelle. Les deux s’arrêtent au même sommet sous le plateau ; leur différence de longueur visible au pied trahit exactement les 60 mm de rehausse.

rehausse = target_height - current_height  # 60 mm : écart vertical entre l'ancien et le nouveau dessous de plateau

ref_plan_x = plateau_length + 300
ref_plan_y = foot_spacing + 200
ref_plan_thickness = 0.5

sol_reel = Pos(0, 0, 0) * Box(
    ref_plan_x, ref_plan_y, ref_plan_thickness,
    align=(Align.CENTER, Align.CENTER, Align.MIN))
sol_reel.label = "sol réel (z=0) — base des manchons"
sol_reel.color = Color(0.4, 0.4, 0.4, 0.25)

sol_avant = Pos(0, 0, rehausse) * Box(
    ref_plan_x, ref_plan_y, ref_plan_thickness,
    align=(Align.CENTER, Align.CENTER, Align.MIN))
sol_avant.label = f"sol avant rehausse (z={rehausse}mm) — niveau absorbé par les manchons"
sol_avant.color = Color(1.0, 0.3, 0.3, 0.25)

bar_section = 8

regle_ancienne = Pos(0, -15, rehausse) * Box(
    bar_section, bar_section, current_height,
    align=(Align.CENTER, Align.CENTER, Align.MIN))
regle_ancienne.label = f"règle ancienne hauteur ({current_height}mm, de z={rehausse} à z={target_height})"
regle_ancienne.color = Color("tomato")

regle_nouvelle = Pos(0, 15, 0) * Box(
    bar_section, bar_section, target_height,
    align=(Align.CENTER, Align.CENTER, Align.MIN))
regle_nouvelle.label = f"règle nouvelle hauteur ({target_height}mm, de z=0 à z={target_height})"
regle_nouvelle.color = Color("mediumseagreen")

children.extend([sol_reel, sol_avant, regle_ancienne, regle_nouvelle])

rendu 3D

On rend les manchons semi-opaques (alpha 0.3) pour voir à travers, mais le backface culling du rendu 3D cache alors les faces intérieures — la cavité ne serait pas visible. On l’affiche donc explicitement en orange opaque (alpha 0.8) positionnée au fond du manchon, là où le pied vient s’emboîter.

Cette vue vérifie les cotes d’emboîtement avant impression : le pied doit s’engager sans jeu excessif ni serrage. La cavité en orange se distingue du bleu du manchon, rendant les faces de contact lisibles malgré la transparence.

Chaque côté affiche sa cavité orange à l’endroit exact où le pied vient s’emboîter dans le manchon, pour rendre l’intérieur lisible sans impression réelle.

cavity_by_side = {
    "grand": (cavity_grand, manchon_length_grand - insertion_depth_grand),
    "petit": (cavity_petit, manchon_length_petit - insertion_depth_petit),
}
children = []
for y in [foot_spacing / 2, -foot_spacing / 2]:
    for side, manchon in [("grand", manchon_grand), ("petit", manchon_petit)]:
        world, pied_coupe = placed_pied(side, y)
        cavity, offset = cavity_by_side[side]
        children += [world * manchon, pied_coupe,
                     world * Pos(0, 0, offset) * cavity]

l’impression

Bambu Lab A1 mini⁶, buse 0.8 mm déjà montée. Deux propriétés de cette combinaison servent la pièce.

L’A1 mini est une bed-slinger : son plateau oscille en Y⁷ pendant l’impression et marque normalement les parois d’ondulations visibles — le ringing. Les extrusions épaisses d’une grosse buse absorbent ces vibrations et masquent le ringing⁸.

L’adhésion inter-couche tient aussi à haut débit : tests Prusa 0.4 vs 0.6 mm, la grosse encaisse +25.6 % d’impact sur pièce testée en choc⁹.

Manchons verticaux, axe aligné Z, petit bout en haut : face rectangulaire (ouverture de la cavité, anneau de paroi tout autour) sur le plateau, calotte ogivale en haut. Premier contact propre, et la calotte se referme au fur et à mesure de la montée Z — dôme auto-porté, pas de supports. L’horizontal serait plus solide (fibres parallèles à la charge) mais exigerait des supports sous la surface ogivale — dégradation du fini sur une pièce de précision d’emboîtement.

Vu l’oscillation en Y, la grande face s’aligne parallèle à X, l’épaisseur selon Y — bras de levier minimal sur l’axe qui vibre. Hauteur totale = manchon_length + manchon_R (la calotte s’ajoute au pavé) ; le petit manchon, plus long, frôle la limite verticale (180 mm⁶) sur base étroite en Y : brim 5-8 mm obligatoire¹⁰.

Quatre paramètres process charpentent la pièce.

Layer 0.4 mm. C’est 50 % du diamètre de buse, le point d’équilibre classique qualité/vitesse[fn:layer-height-0.8]. Monter en 0.6 « extra draft » donnerait un fini trop grossier sur la hauteur du manchon.

4 wall loops. Quatre périmètres de 0.8 mm font 3.2 mm pleins, qui couvrent la paroi modélisée en CAO.

4 top/bottom shell layers. 1.6 mm pleins. Le slicer dépose les top-shells au plafond de la cavité — exactement la zone qui se comprime en usage quand le pied appuie depuis le haut.

15 % gyroïde. Plus dense que les 4 % d’une pièce horizontale : ici l’infill travaille contre les vibrations pendant le print et contre le fléchissement latéral en usage. Le gyroïde est isotrope, pas de direction faible¹¹.

À la marge nominale retenue, la précision FDM ±0.2-0.3 mm élargit la fourchette réelle d’emboîtement — d’où la nécessité d’un test préalable plutôt qu’une marge préventive plus large, qui cumulerait avec les tolérances et deviendrait trop lâche pour l’inclinaison à 21°.

Stratégie : imprimer un seul grand d’abord, tester sur le vrai pied. Le grand valide aussi le petit (même géométrie de cavité, seule l’extension diffère). Trois cas :

• rentre sans forcer → lancer les trois autres
• force légèrement → poncer l’intérieur, ou augmenter légèrement clearance et réimprimer
• ne rentre pas → augmenter davantage clearance et réimprimer

éviter le délaminage

Le vertical met les couches perpendiculaires à la poussée latérale du pied à 21° : cisaillement interlaminaire dans l’axe faible du FDM¹². La compression verticale via les top-shells passe sans effort ; la tenue dépend de la soudure entre couches. Par ordre d’importance.

Flux volumétrique. Levier principal. La formule volumetric_flow = layer_height × line_width × speed¹³ donne le débit matière que le hotend doit fournir.

À 0.8 × 0.4 × 120 mm/s (vitesse typique de paroi externe), on atteint ~38 mm³/s — probablement au-dessus du hotend A1 mini en PLA. L’upgrade E3D ObXidian annonce +70 % et monte à ~26 mm³/s en pointe ; Ellis donne ~15 mm³/s comme référence typique¹⁴. Dépasser ces limites produit une sous-extrusion invisible à l’œil mais aux couches mal fusionnées¹⁵.

Le remède est structurel : on s’appuie sur le preset MVS très conservateur (Generic PLA A1M = 12 mm³/s¹⁶) qui auto-cap les vitesses¹⁷. À 0.8 × 0.4, le cap tombe à ~37 mm/s — print plus lent qu’optimal, mais risque sous-extrusion éliminé par construction.

Température haute. +5 à +10 °C vs preset sur Other layers uniquement (Generic PLA A1M 220 → 225-230 ; PETG preset+10). Grosse buse = plus de matière à chauffer, et la température pilote directement l’adhésion inter-couche : CNC Kitchen mesure 20 MPa à 190 °C, 39 MPa à 210 °C, 37 MPa à 250 °C (optimum 210-230 °C)¹⁸.

Refroidissement réduit (secondaire). 30-40 % max, 0 % sur les 5 premiers mm. Sur paroi verticale épaisse (4 wall loops continus), la hauteur du print donne déjà un refroidissement naturel ; le ventilo à fond casse la soudure¹⁹. Mais dès que le temp bump est appliqué, et en l’absence d’overhangs ou de détails fins (le cas ici), le gain marginal reste faible²⁰ — on laisse le preset Bambu.

Filament sec. 6 h à 45 °C avant un print de 5 h+ (valeurs Prusa PLA)²¹. L’humidité provoque un micro-popping qui initie les délaminages.

Abri des courants d’air. A1 mini ouverte ; manchon haut sur base étroite en Y, long et sensible aux variations thermiques²². Un carton ou cloche souple suffit, loin des portes et fenêtres.

Largeur d’extrusion. Parois à 1.0 mm (vs ~0.88 par défaut en 0.8) : recouvrement latéral accru entre passes, chaque couche mieux ancrée dans la précédente⁴.

À ne pas toucher malgré la tentation : ne pas monter la layer height au-dessus de 0.4 mm pour gagner du temps — on réduirait les couches pleines des top-shells au plafond de la cavité, exactement la zone de compression.

paramètres slicer

Les paramètres, par onglet Bambu Studio.

Process profile — onglet Quality :

• Layer height : 0.4 mm
• Line width > Outer wall : 1.0 mm
• Line width > Inner wall : 1.0 mm

Process profile — onglet Strength :

• Wall loops : 4
• Top shell layers : 4
• Bottom shell layers : 4
• Sparse infill density : 15 %
• Sparse infill pattern : Gyroid

Process profile — onglet Speed :

• Outer wall : 60-65 mm/s
• Inner wall : 80-90 mm/s

Process profile — onglet Others > Skirt/Brim :

• Brim type : Outer brim only (petit manchon)
• Brim width : 5-8 mm

Filament profile — Print temperature > Nozzle :

• Other layers : +5 à +10 °C vs preset (ex : Generic PLA A1M 220 → 225-230)
• Initial layer : ne PAS toucher (sert à l’adhésion plateau, pas à la soudure inter-couche)

Filament profile — Volumetric speed limitation : preset conservé (Generic PLA A1M = 12 mm³/s, très conservateur). Conséquence : MVS = facteur limitant, les vitesses Outer wall / Inner wall ci-dessus sont auto-capées par Bambu Studio à ~37 mm/s (12 ÷ 0.8 × 0.4). Le print sera plus lent qu’optimal mais zéro risque de sous-extrusion. Les ceilings 60-65 / 80-90 restent valides si le MVS est augmenté plus tard.

Filament profile — Cooling (optionnel, presets Bambu conservés par défaut ; ces réglages sont un levier de second ordre quand le temp bump est déjà appliqué, et sans risque significatif ici vu la géométrie — pas d’overhangs, parois épaisses, pas de fine détails) :

• Fan speed > Max fan speed : 30-40 %
• No cooling for the first : ~13 layers (5 mm / 0.4)

Hors slicer :

• filament sec : 6 h à 45 °C avant un print de 5 h+
• abri des courants d’air (A1 mini ouverte)

Ces paramètres sont mis ici -> manchon_petit_pied.3mf

annexe : imports

Les exports STL des manchons reposent sur un même ensemble de primitives build123d.

import math
import build123d as _b123d
from build123d import (
    Align, Box, BuildLine, BuildPart, BuildSketch, Locations,
    Mode, Plane, Pos, RadiusArc, Line, Rot, add, extrude, export_stl,
    fillet, make_face,
)

annexe : sketch et ContextVar avec build123d

build123d détecte normalement la relation parent-enfant entre BuildSketch et BuildPart en inspectant la pile d’appels (inspect.currentframe()). Depuis une fonction, ce contrôle échoue et le sketch n’est pas transféré automatiquement. On contourne en retournant le sketch et en le passant explicitement à extrude — qui retrouve le BuildPart actif via contextvars.ContextVar, lequel se propage correctement à travers les appels de fonction.

annexe : correction trigonométrique pour le pied incliné

En repère local, le bas du demi-cylindre extérieur du manchon est à Z = −R, où R est le rayon du demi-cylindre. Après une rotation de 21° autour de l’axe Y, ce point se projette à Z = −R × cos(21°) — toujours en dessous du sol. Une translation de +R × cos(21°) appliquée après rotation remonte alors le point de contact exactement à Z = 0 — le niveau du sol. C’est l’ordre imposé par Pos(…, lift) * rotation en build123d : la rotation s’applique d’abord, la translation ensuite.

Trois vignettes côte à côte suivent le point de contact : brut dans le repère local, après rotation seule (encore sous le sol), puis après rotation + translation — il atterrit exactement au sol.

Permalink