Adjustable Pressure Increase Per Layer option, snapped to tenths

New "Pressure Increase Per Layer (psi)" number input to the right of the
ramp and pressure-variable checkboxes (default 0.1). Feeds
increase_pressure_per_layer in both pressure formats: variable-mode ramp
expressions become pressureN + step*k and numeric mode bakes the same
steps. The ramp-ceiling warning computes with the chosen step.

Values snap to the tenths place (the regulator's serial protocol
encodes pressure x 10) via an explicit change handler that rewrites the
input in place — gr.Number's precision= rounds before the handler sees
the value, which left stale text in the box, so it is deliberately not
used. The option joins the staleness fingerprint and the settings
export/import round trip.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

README.md

@@ -125,7 +125,7 @@ The **Multi-Nozzle Split** accordion on the **Shapes & G-Code** tab can split on
 - Generated files include pressure preset commands and WAGO valve commands based on the selected pressure, valve, and port; the nozzle number controls layout/spacing assignment.
 - Pressure commands are written **once per port**: when shapes share a serial port, only the first shape's file carries the pressure variable, preset, toggle, and per-layer ramp — the print host compiles every file onto one timeline, and duplicated toggles would flip the regulator on/off/on at start. Valve commands stay per shape in every file.
 - **Editable pressure variable** (checkbox, on by default): each pressure-owning file starts with `{preset}{aux_command}globals().update(pressure3 = 25)` (the value from the Shape Settings table, the variable named after the file's serial port), and every pressure command references that variable — the preset is `setpress(pressure3)` and each ramp step is `setpress(round(min(pressure3 + 0.1, 100), 1))`. To print the same file at a different pressure, edit the one number on the first line; the preset and the entire ramp follow, no regeneration needed. The line's exact shape is dictated by the TCode print host: `{aux_command}` keeps it off the motion timeline (only lines containing `{aux_command}`/`serialPort` are routed as commands), and the host execs all `{preset}` commands as one list literal, so the line must be a pure expression — `globals().update(...)` is the expression form of the assignment. Naming the variable per port keeps multi-port prints independent, since the host runs every file in one shared namespace. Unchecking **Editable Pressure Variable** writes plain numeric pressure commands instead (the pre-variable format, e.g. `setpress(25)` with ramp values baked in), as a fallback in case a host cannot run the variable form.
-- Pressure increases by `0.1` psi per layer by default.
+- Pressure increases by `0.1` psi per layer by default; the **Pressure Increase Per Layer (psi)** option (next to the ramp checkbox) adjusts the step. Values snap to the tenths place — the regulator's serial protocol encodes `pressure × 10`, so finer steps cannot be printed.
 - Pressures are bounded to the regulator's range: table values clamp to 0–100 psi and snap to the tenths place (the serial protocol encodes `pressure × 10`), the ramp expressions clamp at 100 psi even for hand-edited variable values, and the generation status warns when a ramp would hit the ceiling before the last layer.
 - Every movement line is emitted as `G1` at one constant speed (no `G0` rapid travel); the WAGO valve commands mark where material is dispensed vs where the head just travels.
 - **Lead In**: enabled per shape via the **Lead In** column in Shape Settings; the Lead In Options accordion sets the patch geometry. Prints a purge patch before layer 1: **Lead In Position** (Left/Right/Up/Down) picks which side of the shape it sits on, **Lead In Clearance** how far away, and **Lead In Line Direction** which way the purge strokes run — Auto points them at the shape (the historical behavior), or force Horizontal/Vertical (e.g. a patch below the shape with horizontal strokes). The purge always finishes at the patch corner nearest the toolpath start, whatever the line count's parity: strokes running across the approach print the farthest line first and step back toward the shape, and the zigzag starts from whichever end makes the last stroke land on the start corner — so the freshly primed nozzle travels only the short clearance lane to the print, never back across the wet purge lines. For grid-split pieces the clearance is automatically extended by the assembly's remaining extent along the purge axis (reported in the G-code status), so under shared reference motion every nozzle's purge patch lands clear of the whole assembled part instead of on a neighbor's print area. The **Lead In** column in Shape Settings controls dispensing per shape: an opted-out head still travels the shared patch (keeping parallel heads in sync) but keeps its valve shut, and skips the lead-in moves entirely when printing without shared motion.

app.py

@@ -4807,6 +4807,7 @@ def _gcode_settings_snapshot(
     lead_in_orientation: str | None = None,
     contour_order: str | None = None,
     pressure_variable: bool = True,
+    pressure_increase: float = 0.1,
 ) -> dict:
     """Fingerprint of every setting that shapes this record's G-code.
 
@@ -4841,9 +4842,27 @@ def _gcode_settings_snapshot(
         "sweep_buffer": round(_coerce_float(sweep_buffer, 0.8), 6),
         "contour_order": str(contour_order or CONTOUR_ORDER_LAST),
         "pressure_variable": bool(pressure_variable),
+        # Tenths only: the regulator's serial protocol encodes pressure x 10.
+        "pressure_increase": round(max(0.0, _coerce_float(pressure_increase, 0.1)), 1),
     }
 
 
+def snap_pressure_increase_to_tenths(value: Any):
+    """Snap the Pressure Increase Per Layer input to the tenths place.
+
+    The regulator's serial protocol encodes pressure x 10, so finer steps
+    cannot be printed; generation rounds anyway, but snapping the input in
+    place keeps what the user sees equal to what the files will do.
+    Returns gr.skip() when the value is already legal so the corrective
+    update cannot loop.
+    """
+    typed = _coerce_float(value, 0.1)
+    snapped = round(max(0.0, typed), 1)
+    if abs(snapped - typed) < 1e-9:
+        return gr.skip()
+    return gr.update(value=snapped)
+
+
 GCODE_STALE_MESSAGE = (
     "&#9888;&#65039; **Settings changed since this G-code was generated** — "
     "press Generate G-Code again before downloading, visualizing, or printing."
@@ -4866,6 +4885,7 @@ def check_gcode_staleness(
     lead_in_orientation: str | None = None,
     contour_order: str | None = None,
     pressure_variable: bool = True,
+    pressure_increase: float = 0.1,
 ) -> str:
     """Warning banner text when generated G-code no longer matches the settings."""
     records = _apply_shape_settings(records or [], settings_table)
@@ -4885,6 +4905,7 @@ def check_gcode_staleness(
         lead_in_orientation,
         contour_order,
         pressure_variable,
+        pressure_increase,
     )
     for record in records:
         if not record.get("gcode_path"):
@@ -4932,6 +4953,7 @@ def export_project_settings(
     nozzle_speed: Any,
     contour_order: str | None = None,
     pressure_variable: bool = True,
+    pressure_increase: float = 0.1,
     split_columns: Any = None,
     split_rows: Any = None,
     split_overlapping_layers: Any = None,
@@ -4976,6 +4998,7 @@ def export_project_settings(
             "nozzle_speed": _coerce_float(nozzle_speed, 10.0),
             "contour_order": str(contour_order or CONTOUR_ORDER_LAST),
             "pressure_variable": bool(pressure_variable),
+            "pressure_increase": round(max(0.0, _coerce_float(pressure_increase, 0.1)), 1),
             "split_columns": max(1, _coerce_int(split_columns, 2)),
             "split_rows": max(1, _coerce_int(split_rows, 1)),
             "split_overlapping_layers": bool(split_overlapping_layers),
@@ -5007,7 +5030,7 @@ def import_project_settings(
     """
 
     def _skip_options() -> tuple:
-        return tuple(gr.skip() for _ in range(20))
+        return tuple(gr.skip() for _ in range(21))
 
     paths = _uploaded_file_paths(settings_upload)
     if not paths:
@@ -5071,6 +5094,7 @@ def import_project_settings(
         option("nozzle_speed"),
         option("contour_order"),
         option("pressure_variable"),
+        option("pressure_increase"),
         option("split_columns"),
         option("split_rows"),
         option("split_overlapping_layers"),
@@ -5119,9 +5143,13 @@ def generate_dynamic_gcode(
     lead_in_orientation: str | None = None,
     contour_order: str | None = None,
     pressure_variable: bool = True,
+    pressure_increase: float = 0.1,
     progress: gr.Progress = gr.Progress(),
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
+    # Tenths only: the regulator's serial protocol encodes pressure x 10, so
+    # finer ramp steps cannot be printed.
+    pressure_increase = round(max(0.0, _coerce_float(pressure_increase, 0.1)), 1)
     messages: list[str] = []
     progress(0.02, desc="Slicing shapes…")
     _ensure_records_sliced(
@@ -5226,6 +5254,7 @@ def generate_dynamic_gcode(
                 motion_infill_fractions=motion_infill_fractions,
                 emit_pressure_commands=owns_port_pressure,
                 pressure_variable=bool(pressure_variable),
+                increase_pressure_per_layer=pressure_increase,
                 # Same buffer for every shape: the shared motion must match.
                 sweep_buffer=max(0.0, _coerce_float(sweep_buffer, 0.8)),
                 lead_in_enabled=bool(lead_in_enabled),
@@ -5260,14 +5289,16 @@ def generate_dynamic_gcode(
                 lead_in_orientation,
                 contour_order,
                 pressure_variable,
+                pressure_increase,
             )
             messages.append(f"Shape {record['idx']}: wrote `{gcode_path.name}`.")
         except Exception as exc:
             messages.append(f"Shape {record['idx']}: failed ({exc}).")
 
     # Pressure sanity: the regulator tops out at MAX_PRESSURE_PSI, and the
-    # per-layer ramp climbs 0.1 psi per layer — warn when a print would hit
-    # the ceiling (the files clamp there, so later layers hold the maximum).
+    # per-layer ramp climbs pressure_increase psi per layer — warn when a
+    # print would hit the ceiling (the files clamp there, so later layers
+    # hold the maximum).
     if pressure_ramp_enabled and ref_layers is not None and getattr(ref_layers, "layers", None):
         layer_count = len(ref_layers.layers)
         peak_base = max(
@@ -5278,12 +5309,13 @@ def generate_dynamic_gcode(
             ),
             default=0.0,
         )
-        peak = peak_base + 0.1 * max(0, layer_count - 1)
+        peak = peak_base + pressure_increase * max(0, layer_count - 1)
         if peak > MAX_PRESSURE_PSI + 1e-9:
             messages.insert(
                 0,
                 f"&#9888;&#65039; The pressure ramp reaches the {MAX_PRESSURE_PSI:g} psi regulator "
-                f"limit before the last layer (base {peak_base:g} psi + 0.1/layer x {layer_count} "
+                f"limit before the last layer (base {peak_base:g} psi + "
+                f"{pressure_increase:g}/layer x {layer_count} "
                 "layers); the files hold the maximum from there on. Lower the base pressure or "
                 "disable the ramp if that is not intended.",
             )
@@ -5808,17 +5840,33 @@ def build_dynamic_demo() -> gr.Blocks:
                 All shapes share one combined nozzle path (each dispenses only its own geometry), so parallel heads always stay in sync.
                 """
             )
-            gcode_pressure_ramp_enabled = gr.Checkbox(label="Increase Pressure Each Layer", value=True)
-            gcode_pressure_variable = gr.Checkbox(
-                label="Editable Pressure Variable",
-                value=True,
-                info=(
-                    "Start each pressure-owning file with a pressureN variable that every "
-                    "pressure command references, so the print pressure can be changed by "
-                    "editing one number in the file — no regeneration needed. Uncheck to "
-                    "write plain numeric pressure commands instead."
-                ),
-            )
+            with gr.Row():
+                gcode_pressure_ramp_enabled = gr.Checkbox(
+                    label="Increase Pressure Each Layer", value=True, scale=1
+                )
+                gcode_pressure_variable = gr.Checkbox(
+                    label="Editable Pressure Variable",
+                    value=True,
+                    scale=2,
+                    info=(
+                        "Start each pressure-owning file with a pressureN variable that every "
+                        "pressure command references, so the print pressure can be changed by "
+                        "editing one number in the file — no regeneration needed. Uncheck to "
+                        "write plain numeric pressure commands instead."
+                    ),
+                )
+                # No precision= here: Gradio would round BEFORE the change
+                # handler sees the value, so the snap-to-tenths correction
+                # below would never know the display needs rewriting.
+                gcode_pressure_increase = gr.Number(
+                    label="Pressure Increase Per Layer (psi)",
+                    value=0.1,
+                    minimum=0.0,
+                    step=0.1,
+                    scale=1,
+                    min_width=170,
+                    info="Added each layer when Increase Pressure Each Layer is on. Tenths only.",
+                )
             with gr.Row(elem_id="gcode-raster-row"):
                 gcode_raster_pattern = gr.Dropdown(
                     label="Raster Pattern",
@@ -6255,6 +6303,7 @@ def build_dynamic_demo() -> gr.Blocks:
                 viz_nozzle_speed,
                 gcode_contour_order,
                 gcode_pressure_variable,
+                gcode_pressure_increase,
                 split_columns,
                 split_rows,
                 split_overlapping_layers,
@@ -6286,6 +6335,7 @@ def build_dynamic_demo() -> gr.Blocks:
                 viz_nozzle_speed,
                 gcode_contour_order,
                 gcode_pressure_variable,
+                gcode_pressure_increase,
                 split_columns,
                 split_rows,
                 split_overlapping_layers,
@@ -6314,6 +6364,7 @@ def build_dynamic_demo() -> gr.Blocks:
             gcode_lead_in_orientation,
             gcode_contour_order,
             gcode_pressure_variable,
+            gcode_pressure_increase,
         ]
         shape_settings.change(
             fn=check_gcode_staleness,
@@ -6335,6 +6386,7 @@ def build_dynamic_demo() -> gr.Blocks:
             gcode_lead_in_orientation,
             gcode_contour_order,
             gcode_pressure_variable,
+            gcode_pressure_increase,
         ):
             stale_control.change(
                 fn=check_gcode_staleness,
@@ -6342,6 +6394,14 @@ def build_dynamic_demo() -> gr.Blocks:
                 outputs=[gcode_stale_banner],
                 queue=False,
             )
+        # Snap finer-than-tenths ramp steps back in place (the regulator
+        # resolves tenths); skips when already legal so it cannot loop.
+        gcode_pressure_increase.change(
+            fn=snap_pressure_increase_to_tenths,
+            inputs=[gcode_pressure_increase],
+            outputs=[gcode_pressure_increase],
+            queue=False,
+        )
 
         apply_rotation_button.click(
             fn=apply_shape_z_rotation,
@@ -6425,6 +6485,7 @@ def build_dynamic_demo() -> gr.Blocks:
                 gcode_lead_in_orientation,
                 gcode_contour_order,
                 gcode_pressure_variable,
+                gcode_pressure_increase,
             ],
             outputs=[shape_records, ref_layers, gcode_downloads, gcode_status, gcode_text_source, gcode_source, gcode_download_all],
         ).then(

tests/test_nozzle_spacing.py

@@ -2001,6 +2001,17 @@ def test_rotate_all_shapes_at_once(tmp_path) -> None:
     assert (cleared[1]["target_x"], cleared[1]["target_y"]) == (6.0, 2.0)
 
 
+def test_pressure_increase_input_snaps_to_tenths() -> None:
+    from app import snap_pressure_increase_to_tenths
+
+    # Finer than tenths snaps in place (the regulator encodes pressure x 10).
+    assert snap_pressure_increase_to_tenths(0.26)["value"] == 0.3
+    assert snap_pressure_increase_to_tenths(-0.4)["value"] == 0.0
+    # Already-legal values are skipped so the corrective update cannot loop.
+    snapped = snap_pressure_increase_to_tenths(0.3)
+    assert not (isinstance(snapped, dict) and "value" in snapped)
+
+
 def test_project_settings_export_import_round_trip(tmp_path) -> None:
     from app import export_project_settings, import_project_settings
 
@@ -2011,7 +2022,7 @@ def test_project_settings_export_import_round_trip(tmp_path) -> None:
     settings_path, status = export_project_settings(
         records, None, 0.4, 0.4, None, "Circle Spiral raster", False, 1.2,
         6.0, 7.0, 4, "Down", "Horizontal", 15.0,
-        pressure_variable=False,
+        pressure_variable=False, pressure_increase=0.3,
         split_columns=3, split_rows=2, split_overlapping_rows=True,
         split_overlap=1.5,
     )
@@ -2035,10 +2046,11 @@ def test_project_settings_export_import_round_trip(tmp_path) -> None:
     assert option_updates[8]["value"] == 0.4  # layer height
     assert option_updates[11]["value"] == 15.0  # nozzle speed
     assert option_updates[13]["value"] is False  # pressure variable off
-    assert option_updates[14]["value"] == 3  # split columns
-    assert option_updates[15]["value"] == 2  # split rows
-    assert option_updates[17]["value"] is True  # overlapping rows
-    assert option_updates[19]["value"] == 1.5  # overlap mm
+    assert option_updates[14]["value"] == 0.3  # pressure increase per layer
+    assert option_updates[15]["value"] == 3  # split columns
+    assert option_updates[16]["value"] == 2  # split rows
+    assert option_updates[18]["value"] is True  # overlapping rows
+    assert option_updates[20]["value"] == 1.5  # overlap mm
 
     # A file listed in the export but not loaded is reported.
     partial = import_project_settings([settings_path], _records_from_files(["egg_inside.stl"], None), None)

tests/test_vector_gcode.py

@@ -469,6 +469,31 @@ def test_pressure_variable_can_be_disabled(tmp_path) -> None:
     assert _pressure_values(text) == [25.0, 25.1, 25.2]
 
 
+def test_pressure_ramp_increment_is_adjustable(tmp_path) -> None:
+    # The "Pressure Increase Per Layer" option feeds
+    # increase_pressure_per_layer; both pressure formats honor it.
+    layer = box(0.0, 0.0, 2.0, 2.0)
+
+    def _generate(label: str, variable: bool) -> str:
+        path = generate_vector_gcode(
+            _stack(layer, layer, layer),
+            shape_name=label,
+            pressure=25,
+            valve=7,
+            port=3,
+            fil_width=1.0,
+            layer_height=1.0,
+            pressure_ramp_enabled=True,
+            pressure_variable=variable,
+            increase_pressure_per_layer=0.5,
+            output_dir=tmp_path / label,
+        )
+        return path.read_text()
+
+    assert _pressure_values(_generate("with_variable", True)) == [25.0, 25.5, 26.0]
+    assert _pressure_values(_generate("numeric", False)) == [25.0, 25.5, 26.0]
+
+
 def test_gcode_lead_in_runs_once_before_first_layer(tmp_path) -> None:
     gcode_path = generate_vector_gcode(
         _stack(box(0.0, 0.0, 0.5, 0.5), box(0.0, 0.0, 0.5, 0.5)),