constructelligence's picture
Update code: real-machine G-code adapter, commissioning gate, machine_job runner, pump watchdog firmware, twin completion gate, realism and masking modules (card and weights unchanged)
4eecd03 verified
Raw History Blame Contribute Delete
10.2 kB
#!/usr/bin/env python3
"""Application physics: how fast to move, how far apart to pass, and how much paint, for a film-thickness target.
The planner says *where* the tool goes; a coating spec says *how thick* the film must be. This module joins them.
Every relation is the standard one painters and coating inspectors use, with the assumptions written down:
* **Airless spray fan width** at the wall = 2 × standoff × tan(fan angle / 2). Tip codes follow the common
three-digit convention: first digit × 2 = fan width in inches at a 12 in standoff, last two digits = orifice in
thousandths of an inch (e.g. ``517`` = 10 in fan, 0.017 in orifice).
* **Tip flow** scales with the square root of pressure: Q = Q_rated × √(P / P_rated). ``TIP_FLOW_GPM`` holds
typical water-rated flows at 2000 psi; a manufacturer's chart for the actual tip and coating always wins.
* **Deposition.** With pass spacing ``s`` (fan width × (1 − overlap)) and traverse speed ``v``, the average wet film
is WFT = Q × TE / (v × s), where TE is transfer efficiency (paint that reaches the wall, not the air).
Dry film = WFT × volume solids. Solving for ``v`` gives the speed that hits a dry-film target.
* **Roller.** Rollers are specified by spread rate: area per volume at the target film; one load covers
``load_ml / (DFT / VS)`` of wall, which sets how often the robot must reload.
Units: SI internally (m, s, L, µm); inches/mils/gallons in and out where the trade uses them.
python3 application.py spray --tip 517 --pressure-psi 2000 --standoff-mm 300 --dft-um 40 --vs 0.38 --area-m2 42
"""
from __future__ import annotations
import argparse
import json
import math
from dataclasses import dataclass, asdict
GPM_TO_LPS = 3.785411784 / 60.0
INCH_MM = 25.4
MIL_UM = 25.4
# Typical water flow (US gal/min) at 2000 psi by orifice (thousandths of an inch). Order-of-magnitude values from
# common airless tip charts — use the manufacturer's chart for the tip actually fitted.
TIP_FLOW_GPM = {11: 0.12, 13: 0.18, 15: 0.24, 17: 0.31, 19: 0.38, 21: 0.47, 23: 0.57, 25: 0.67, 27: 0.78, 31: 1.03}
@dataclass(frozen=True)
class SprayTip:
code: str
fan_in_at_12: float
orifice_thou: int
@staticmethod
def parse(code: str) -> "SprayTip":
code = str(code).strip()
if len(code) != 3 or not code.isdigit():
raise ValueError(f"tip code {code!r}: expected three digits such as 517")
orifice = int(code[1:])
if orifice not in TIP_FLOW_GPM:
raise ValueError(f"tip {code}: no flow figure for a 0.0{orifice:02d} in orifice; pass --flow-lpm")
return SprayTip(code, int(code[0]) * 2.0, orifice)
@property
def fan_angle_deg(self) -> float:
return math.degrees(2 * math.atan((self.fan_in_at_12 / 2) / 12.0))
def flow_lps(self, pressure_psi: float, rated_psi: float = 2000.0) -> float:
return TIP_FLOW_GPM[self.orifice_thou] * GPM_TO_LPS * math.sqrt(pressure_psi / rated_psi)
def fan_width_mm(standoff_mm: float, fan_angle_deg: float) -> float:
return 2 * standoff_mm * math.tan(math.radians(fan_angle_deg) / 2)
def spray_settings(flow_lps, fan_angle_deg, standoff_mm, dft_um, volume_solids, overlap=0.5, transfer_efficiency=0.65,
coats=1, area_m2=None, max_speed_mm_s=1500.0, min_speed_mm_s=150.0, max_wet_um=200.0):
"""Pass spacing, traverse speed and paint for one coat (and the job, given an area). Raises on an impossible spec."""
if not 0 < volume_solids <= 1 or not 0 < transfer_efficiency <= 1 or not 0 <= overlap < 1:
raise ValueError("volume_solids and transfer_efficiency must be in (0, 1], overlap in [0, 1)")
width = fan_width_mm(standoff_mm, fan_angle_deg)
spacing = width * (1 - overlap)
wft_um = dft_um / volume_solids
# WFT (m) = Q (m³/s) × TE / (v (m/s) × s (m)) -> v = Q × TE / (WFT × s)
speed_m_s = flow_lps / 1000.0 * transfer_efficiency / (wft_um * 1e-6 * spacing / 1000.0)
speed = speed_m_s * 1000.0
notes = []
if speed > max_speed_mm_s:
notes.append(f"needs {speed:.0f} mm/s, above the {max_speed_mm_s:.0f} mm/s limit: use a smaller tip or lower pressure")
if wft_um > max_wet_um:
notes.append(f"{wft_um:.0f} µm wet in one coat is above ~{max_wet_um:.0f} µm, where wall paints sag: split into coats")
if speed < min_speed_mm_s:
notes.append(f"needs only {speed:.0f} mm/s: risk of runs; use a larger fan, a smaller orifice, or two thinner coats")
out = {"fan_width_mm": round(width, 1), "pass_spacing_mm": round(spacing, 1), "wet_film_um": round(wft_um, 1),
"wet_film_mils": round(wft_um / MIL_UM, 2), "dry_film_um": dft_um, "traverse_speed_mm_s": round(speed, 1),
"flow_l_min": round(flow_lps * 60, 3), "transfer_efficiency": transfer_efficiency,
"fan_angle_deg": round(fan_angle_deg, 2), "standoff_mm": standoff_mm, "notes": notes}
if area_m2:
paint_l = area_m2 * wft_um * 1e-6 * 1000.0 / transfer_efficiency * coats # litres pumped, incl. overspray
spray_s = paint_l / flow_lps
out.update({"area_m2": area_m2, "coats": coats, "paint_l": round(paint_l, 2), "paint_gal": round(paint_l / 3.785, 2),
"trigger_on_time_min": round(spray_s / 60, 1),
"pass_length_m": round(area_m2 * coats / (spacing / 1000.0), 1)})
return out
def roller_settings(nap_load_ml, dft_um, volume_solids, roller_width_mm=230.0, overlap=0.2, area_m2=None, coats=1):
"""How much wall one roller load covers at the target film, and the reload count for an area."""
wft_um = dft_um / volume_solids
per_load_m2 = nap_load_ml * 1e-6 / (wft_um * 1e-6)
out = {"wet_film_um": round(wft_um, 1), "area_per_load_m2": round(per_load_m2, 3),
"pass_spacing_mm": round(roller_width_mm * (1 - overlap), 1),
"stroke_length_per_load_m": round(per_load_m2 / (roller_width_mm * (1 - overlap) / 1000.0), 2)}
if area_m2:
out.update({"loads": math.ceil(area_m2 * coats / per_load_m2), "paint_l": round(area_m2 * coats * wft_um * 1e-3, 2)})
return out
def trigger_offsets(speed_mm_s, open_latency_s=0.05, close_latency_s=0.03):
"""How far before a stroke's start the gun must be told to open (and before its end to close) at this speed."""
return {"open_lead_mm": round(speed_mm_s * open_latency_s, 1), "close_lead_mm": round(speed_mm_s * close_latency_s, 1)}
def spray_reaction(flow_lps, pressure_psi, density_kg_m3=1100.0):
"""The push the jet puts back on the gun, and so on whatever is holding it.
Reaction is mass flow times exit speed: F = (Q rho) * sqrt(2 P / rho) = Q * sqrt(2 P rho). An airless tip at
2000 psi moving 1.17 L/min therefore pushes back with about 3.4 N (0.35 kgf). That is small next to a drone's
thrust, and it is not small next to the *quality* budget: it acts for a whole pass, on a long boom, and it moves the
nozzle off its standoff, which changes the fan width and so the film.
``density`` is the coating's (~1100 kg/m3 for wall paint); the pressure is the one at the tip, and a measured flow
always beats the tip table. The model ignores the fan's impingement on the wall (a wall jet pushes back a little
more) and any swirl: it is a lower bound, and it is stated as one.
"""
flow_lps, pressure_psi, density = float(flow_lps), float(pressure_psi), float(density_kg_m3)
if flow_lps < 0 or pressure_psi < 0 or density <= 0:
raise ValueError("flow, pressure and density must be non-negative (density positive)")
pressure_pa = pressure_psi * 6894.757
exit_ms = math.sqrt(2.0 * pressure_pa / density)
mass_flow = flow_lps / 1000.0 * density # L/s -> m3/s -> kg/s
force = mass_flow * exit_ms
return {"exit_ms": round(exit_ms, 1), "mass_flow_kg_s": round(mass_flow, 5),
"reaction_n": round(force, 2), "reaction_kg": round(force / 9.80665, 3),
"density_kg_m3": density, "pressure_psi": pressure_psi}
def main():
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
sub = ap.add_subparsers(dest="mode", required=True)
s = sub.add_parser("spray")
s.add_argument("--tip", help="three-digit tip code, e.g. 517")
s.add_argument("--flow-lpm", type=float, help="measured flow instead of the tip table")
s.add_argument("--fan-deg", type=float, help="fan angle, with --flow-lpm")
s.add_argument("--pressure-psi", type=float, default=2000)
s.add_argument("--standoff-mm", type=float, default=300)
s.add_argument("--dft-um", type=float, required=True, help="dry film per coat from the product data sheet")
s.add_argument("--vs", type=float, required=True, help="volume solids, 0-1, from the product data sheet")
s.add_argument("--overlap", type=float, default=0.5)
s.add_argument("--te", type=float, default=0.65, help="transfer efficiency")
s.add_argument("--area-m2", type=float)
s.add_argument("--coats", type=int, default=1)
r = sub.add_parser("roller")
r.add_argument("--load-ml", type=float, default=60)
r.add_argument("--dft-um", type=float, required=True)
r.add_argument("--vs", type=float, required=True)
r.add_argument("--width-mm", type=float, default=230)
r.add_argument("--area-m2", type=float)
r.add_argument("--coats", type=int, default=1)
a = ap.parse_args()
if a.mode == "spray":
if a.tip:
tip = SprayTip.parse(a.tip)
flow, angle = tip.flow_lps(a.pressure_psi), tip.fan_angle_deg
elif a.flow_lpm and a.fan_deg:
flow, angle = a.flow_lpm / 60.0, a.fan_deg
else:
ap.error("give --tip, or --flow-lpm with --fan-deg")
out = spray_settings(flow, angle, a.standoff_mm, a.dft_um, a.vs, a.overlap, a.te, a.coats, a.area_m2)
out["trigger"] = trigger_offsets(out["traverse_speed_mm_s"])
out["reaction"] = spray_reaction(flow, a.pressure_psi)
else:
out = roller_settings(a.load_ml, a.dft_um, a.vs, a.width_mm, area_m2=a.area_m2, coats=a.coats)
print(json.dumps(out, indent=2))
if __name__ == "__main__":
main()