AI Flow

@@ -189,7 +189,7 @@ pub fn molecule_check_bom(b: &Board, spec: &Value, before: Option<&Board>, bom:     let grid = m["gridMm"].as_f64().unwrap_or(2.0);     let margin = m["edgeMarginMm"].as_f64().unwrap_or(2.0);     let pin_net = m["cornerPinsNet"].as_str().unwrap_or("GND").to_string();-    let hint_fp = "Use the Adom KiCad Library 1.2.3 footprints (lib/Molecule.pretty): MachinePinMediumShort 1.6 mm pad / 1.2 mm drill (or MachinePinLargeShort / LargeStandard 5.2 mm pad / 3.45 mm drill when the corner-pin class rule needs large pins) for MP1 to MP4, MachineContactMedium 1.3 mm pad / 0.78 mm drill for contacts; spec.molecule.pinPadMm / pinDrillMm / contactPadMm / contactDrillMm override the expected sizes (skill aiflow-molecule).";+    let hint_fp = "Use the Adom KiCad Library 1.2.3 footprints (lib/Molecule.pretty): MachinePinMediumShort 1.6 mm pad / 1.2 mm drill (or MachinePinLargeShort / LargeStandard 5.2 mm pad / 3.45 mm drill when the corner-pin class rule needs large pins) for MP1 to MP4, MachineContactMedium 1.3 mm pad / 0.78 mm drill for contacts (MachineContactLarge 4.4 mm pad / 2.62 mm drill for a power net over 3.5 A, which takes large corner pins); spec.molecule.pinPadMm / pinDrillMm / contactPadMm / contactDrillMm override the expected sizes (skill aiflow-molecule).";     let pad_of = |r: &str| b.pads_of(r).into_iter().next().cloned();     let mut pins: BTreeMap<String, (f64, f64)> = BTreeMap::new();     for k in 1..=4 {@@ -357,8 +357,16 @@ pub const LARGE_PIN_SIDE_MM: f64 = 100.0; pub const LARGE_PIN_CURRENT_A: f64 = 3.5; /// A heatsink heavier than this is a load that pushes, pulls or twists the board. pub const LARGE_PIN_HEATSINK_G: f64 = 20.0;+/// The large pin and contact class rating: a net carried only by large parts is judged against this.+pub const LARGE_CLASS_CURRENT_A: f64 = 20.8; const MECH_KINDS: [&str; 5] = ["motor", "actuator", "heatsink", "cabled-connector", "button"]; +/// A large machine pin or contact (MachinePinLarge*, MachineContactLarge), by footprint name.+fn is_large_machine_part(lib: &str) -> bool {+    let name = lib.rsplit(':').next().unwrap_or(lib).to_ascii_lowercase();+    name.starts_with("machinepinlarge") || name == "machinecontactlarge"+}+ /// The board's corner-pin class: "medium", "large", "mixed", or None when a pin is missing or not a MachinePin. fn corner_pin_class(b: &Board) -> Option<&'static str> {     let mut classes = BTreeSet::new();@@ -409,7 +417,9 @@ pub fn bom_mass(bom: &str) -> Option<(f64, usize, String)> { /// MachinePinLargeStandard on LrgMed user-scaffold corners) when ANY of: the board seats directly in /// the base scaffold; the board with its parts weighs more than 100 g; it carries a load that pushes, /// pulls or twists it (motor, actuator, heatsink over 20 g, cabled connector, button pressed hard);-/// its longest side is over 100 mm; a pin carries more than 3.5 A. Otherwise medium (MediumShort).+/// its longest side is over 100 mm; a pin carries more than 3.5 A; it has a large contact+/// (MachineContactLarge), unless spec.molecule.largeContactMediumPins says why medium is right.+/// Otherwise medium (MediumShort). fn pin_class_check(b: &Board, spec: &Value, m: &Value, bom: Option<&str>, f: &mut Findings) {     let mut reasons: Vec<String> = Vec::new();     let mut notes: Vec<String> = Vec::new();@@ -442,12 +452,22 @@ fn pin_class_check(b: &Board, spec: &Value, m: &Value, bom: Option<&str>, f: &mu             if !e.contains(r) { e.push(r.clone()); }         }     }+    // a net whose every carrier is a large pin or contact is within the large class rating, not the+    // medium one: it says nothing about the corner pins (a 12 A rail on large contacts)+    let all_large = |refs: &[String]| refs.iter().all(|r| b.footprints.get(r).map(|fp| is_large_machine_part(&fp.lib)).unwrap_or(false));     let mut pin_amps: Option<(f64, String)> = None;     if let Some(loads) = spec["loads"].as_object() {         for (net, ld) in loads {             let amps = ld["amps"].as_f64().or_else(|| ld.as_f64()).unwrap_or(0.0);             if let Some(refs) = carriers.get(&norm_net(net)) {-                if pin_amps.as_ref().map(|p| amps > p.0).unwrap_or(true) { pin_amps = Some((amps, format!("net {} ({})", norm_net(net), refs.join(", ")))); }+                let what = format!("net {} ({})", norm_net(net), refs.join(", "));+                if all_large(refs) {+                    if amps > LARGE_CLASS_CURRENT_A {+                        f.warn(format!("{what} carries {amps} A (spec.loads), over the large class's {LARGE_CLASS_CURRENT_A} A"), "Share that rail across more large contacts, or declare the reviewed per-contact current (skill aiflow-molecule, corner-pin class).");+                    } else { notes.push(format!("{what} carries {amps} A on large parts only (rated {LARGE_CLASS_CURRENT_A} A)")); }+                    continue;+                }+                if pin_amps.as_ref().map(|p| amps > p.0).unwrap_or(true) { pin_amps = Some((amps, what)); }             }         }     }@@ -535,12 +555,34 @@ fn pin_class_check(b: &Board, spec: &Value, m: &Value, bom: Option<&str>, f: &mu             notes.push(format!("{} confirmed as no mechanical load (not in spec.molecule.mechanicalLoads)", undeclared.join(", ")));         }     }+    // (6) a large contact: the board takes heavy current or a heavy wire, so its corners go large too,+    // unless spec.molecule.largeContactMediumPins says why medium corners are right for this board+    let large_contacts: Vec<String> = b.footprints.iter()+        .filter(|(_, fp)| fp.lib.rsplit(':').next().unwrap_or(&fp.lib).eq_ignore_ascii_case("machinecontactlarge"))+        .map(|(r, _)| r.clone()).collect();+    let keep_medium = match m.get("largeContactMediumPins") {+        Some(Value::String(s)) if !s.trim().is_empty() => Some(s.trim().to_string()),+        None | Some(Value::Null) => None,+        Some(_) => { f.warn("spec.molecule.largeContactMediumPins must be a sentence saying why medium corner pins are right with a large contact; it is ignored".into(), declare_hint); None }+    };+    let override_hint = "When medium corner pins are right for this board anyway (a light board in a LrgMed user scaffold, say), keep them on purpose: set spec.molecule.largeContactMediumPins to the reason (skill aiflow-molecule, corner-pin class).";+    let mut overridable = false;+    match (large_contacts.is_empty(), &keep_medium) {+        (false, None) => { reasons.push(format!("{} is a large contact (MachineContactLarge); a board with a large contact takes large corner pins", large_contacts.join(", "))); overridable = true; }+        (false, Some(why)) => notes.push(format!("large contact {}, medium corner pins kept on purpose (spec.molecule.largeContactMediumPins: {why})", large_contacts.join(", "))),+        (true, Some(_)) => f.warn("spec.molecule.largeContactMediumPins is set but the board has no MachineContactLarge".into(), "Remove it, or add the large contact it was written for."),+        (true, None) => {}+    }     // the decision     let class = corner_pin_class(b);     let required = if reasons.is_empty() { "medium" } else { "large" };     match (required, class) {-        ("large", Some("medium")) => f.error(format!("corner pins are medium but this board needs LARGE pins: {}", reasons.join("; ")),-            "Use MachinePinLargeShort for MP1 to MP4 (MachinePinLargeStandard where this board is a LrgMed user scaffold's corners), seated on the base scaffold's 32 mm grid. A large pin is not a footprint-name swap: update the schematic, library, BOM, layout, models and fixture (skill aiflow-molecule, corner-pin class)."),+        ("large", Some("medium")) => {+            f.error(format!("corner pins are medium but this board needs LARGE pins: {}", reasons.join("; ")),+                "Use MachinePinLargeShort for MP1 to MP4 (MachinePinLargeStandard where this board is a LrgMed user scaffold's corners), seated on the base scaffold's 32 mm grid. A large pin is not a footprint-name swap: update the schematic, library, BOM, layout, models and fixture (skill aiflow-molecule, corner-pin class).");+            // only the large-contact reason can be overridden; say so when it is the only one+            if overridable && reasons.len() == 1 { f.hints.push(override_hint.to_string()); }+        }         ("large", Some("large")) => f.ok(format!("large corner pins, as needed: {}", reasons.join("; "))),         ("medium", Some("large")) => f.ok(format!("large corner pins; medium would do (no large-pin reason: {}). Large is allowed", if notes.is_empty() { "nothing declared".to_string() } else { notes.join(", ") })),         ("medium", Some("medium")) => f.ok(format!("medium corner pins: no large-pin reason ({})", if notes.is_empty() { "nothing declared".to_string() } else { notes.join(", ") })),@@ -551,7 +593,8 @@ fn pin_class_check(b: &Board, spec: &Value, m: &Value, bom: Option<&str>, f: &mu     }     f.pin_class = json!({"required": required, "pins": class, "reasons": reasons, "notes": notes, "seat": seat,         "longestSideMm": longest.map(|v| (v * 100.0).round() / 100.0), "massG": mass.as_ref().map(|x| x.0), "massSource": mass.as_ref().map(|x| x.1.clone()),-        "pinCurrentA": pin_amps.as_ref().map(|x| x.0), "pinCurrentFrom": pin_amps.as_ref().map(|x| x.1.clone())});+        "pinCurrentA": pin_amps.as_ref().map(|x| x.0), "pinCurrentFrom": pin_amps.as_ref().map(|x| x.1.clone()),+        "largeContacts": large_contacts, "largeContactMediumPins": keep_medium}); }  // ----------------------------------------------------------------------------- fab rules (#10)@@ -1031,6 +1074,67 @@ mod tests {             .replace("124", "132").replace(" 84", " 68").replace("(start 98 82)", "(start 96 64)").replace("(end 126 102)", "(end 136 104)")     } +    /// A MachineContactLarge J2 on VMOT, 6 mm right of J1 (on the 2 mm grid from MP1).+    fn with_large_contact(text: &str) -> String {+        text.replacen(" (footprint \"Resistor_SMD", " (footprint \"Molecule:MachineContactLarge\" (layer \"F.Cu\") (at 106 88) (property \"Reference\" \"J2\") (pad \"1\" thru_hole circle (at 0 0) (size 4.4 4.4) (drill 2.62) (layers \"*.Cu\") (net \"VMOT\")))\n (footprint \"Resistor_SMD", 1)+    }++    #[test]+    fn pin_class_large_contact_needs_large_corners() {+        let f = molecule_check(&board(&with_large_contact(BOARD)), &calm(json!({})), None);+        let e = pin_errors(&f);+        assert!(e.len() == 1 && e[0].contains("J2 is a large contact"), "{:?}", f.lines);+        assert!(f.hints.iter().any(|h| h.contains("largeContactMediumPins")), "{:?}", f.hints);+        assert_eq!(f.pin_class["required"], "large");+        assert_eq!(f.pin_class["largeContacts"], json!(["J2"]));+        // the contact itself passes the contact checks (4.4 mm pad, 2.62 mm drill, on the grid)+        assert!(f.lines.iter().any(|l| l.starts_with("OK") && l.contains("J2 MachineContactLarge")), "{:?}", f.lines);+        // large corners: as needed+        let f = molecule_check(&board(&with_large_contact(&large_board())), &calm(json!({"seat": "base"})), None);+        assert!(f.errors.is_empty(), "{:?}", f.lines);+        assert!(f.lines.iter().any(|l| l.contains("large corner pins, as needed") && l.contains("J2")), "{:?}", f.lines);+    }++    #[test]+    fn pin_class_large_contact_override_keeps_medium() {+        let why = "light 28 x 20 mm board in a LrgMed scaffold; J2 is only the 14 AWG motor feed";+        let mut spec = calm(json!({"largeContactMediumPins": why}));+        spec["loads"] = json!({"VMOT": {"amps": 12}});+        let f = molecule_check(&board(&with_large_contact(BOARD)), &spec, None);+        // 12 A on a net only the large contact carries is within the large rating, not a medium-pin reason+        assert!(f.errors.is_empty() && f.warnings.is_empty(), "{:?}", f.lines);+        assert_eq!(f.pin_class["required"], "medium");+        assert_eq!(f.pin_class["largeContactMediumPins"], why);+        assert!(f.pin_class["notes"].as_array().unwrap().iter().any(|n| n.as_str().unwrap().contains("kept on purpose")), "{}", f.pin_class);+        // the override covers the large contact only, never another reason+        let f = molecule_check(&board(&with_large_contact(BOARD)), &calm(json!({"largeContactMediumPins": why, "massG": 150})), None);+        let e = pin_errors(&f);+        assert!(e.len() == 1 && e[0].contains("150 g") && !e[0].contains("J2"), "{:?}", f.lines);+        // it has to say why+        let f = molecule_check(&board(&with_large_contact(BOARD)), &calm(json!({"largeContactMediumPins": true})), None);+        assert!(f.warnings.iter().any(|w| w.contains("must be a sentence")), "{:?}", f.lines);+        assert!(!pin_errors(&f).is_empty());+        // and it needs a large contact to apply to+        let f = molecule_check(&board(BOARD), &calm(json!({"largeContactMediumPins": why})), None);+        assert!(f.errors.is_empty() && f.warnings.iter().any(|w| w.contains("no MachineContactLarge")), "{:?}", f.lines);+    }++    #[test]+    fn pin_class_large_only_net_is_judged_against_the_large_rating() {+        let text = with_large_contact(&large_board());+        let mut spec = calm(json!({"seat": "base"}));+        spec["loads"] = json!({"VMOT": {"amps": 12}});+        let f = molecule_check(&board(&text), &spec, None);+        assert!(f.errors.is_empty() && f.warnings.is_empty(), "{:?}", f.lines);+        spec["loads"] = json!({"VMOT": {"amps": 25}});+        let f = molecule_check(&board(&text), &spec, None);+        assert!(f.warnings.iter().any(|w| w.contains("net VMOT (J2) carries 25 A") && w.contains("20.8 A")), "{:?}", f.lines);+        // a medium contact on the same heavy net still counts against the medium rating+        let shared = with_large_contact(BOARD).replace("(net \"VIN\")))", "(net \"VMOT\")))");+        let f = molecule_check(&board(&shared), &calm(json!({"largeContactMediumPins": "test"})).tap_loads(json!({"VMOT": {"amps": 12}})), None);+        assert!(pin_errors(&f).iter().any(|e| e.contains("net VMOT (J1, J2) carries 12 A")), "{:?}", f.lines);+    }+     #[test]     fn pin_class_large_pins_with_no_reason_pass() {         let f = molecule_check(&board(&large_board()), &calm(json!({"seat": "board"})), None);