KiCAD Schematic Exporter MVP

examples/dev_schematics.py

@@ -0,0 +1,56 @@
+"""
+This is developer-targeted example for generating schematics.
+Schematics are an alpha feature-in-progress, which means they're not bundled up nicely
+with the rest of the exporter.
+"""
+
+import logging
+from pathlib import Path
+
+import iterative_design_nand
+import minimal_led
+
+from faebryk.exporters.schematic.kicad.transformer import Transformer
+from faebryk.libs.examples.buildutil import apply_design_to_pcb
+from faebryk.libs.kicad.fileformats_sch import C_kicad_sch_file
+from faebryk.libs.logging import setup_basic_logging
+from faebryk.libs.util import CouldntOSOpen, os_open
+
+logger = logging.getLogger(__name__)
+
+
+def build(module) -> Path:
+    build_dir = Path(".") / "build"
+    lib_path = build_dir / "kicad" / "libs"
+
+    sch_file = C_kicad_sch_file.skeleton()
+
+    logger.info("Building app")
+    app = module.App()
+
+    logger.info("Applying design to PCB")
+    apply_design_to_pcb(app)
+
+    logger.info("Generating schematic")
+    full_transformer = Transformer(sch_file.kicad_sch, app.get_graph(), app)
+    full_transformer.index_symbol_files(lib_path, load_globals=False)
+
+    full_transformer.generate_schematic()
+
+    output_path = build_dir / f"{module.__name__}.kicad_sch"
+    sch_file.dumps(output_path)
+    return output_path
+
+
+if __name__ == "__main__":
+    setup_basic_logging()
+
+    for module in [minimal_led, iterative_design_nand]:
+        logger.info(f"Building {module.__name__}")
+        path = build(module)
+
+        logger.info(f"Opening {path}")
+        try:
+            os_open(path)
+        except CouldntOSOpen as ex:
+            logger.error(f"Can't open {path}: {ex}")

examples/iterative_design_nand.py

@@ -135,6 +135,8 @@ def App():
     for ic_nand, xor_nand in zip(nand_ic.gates, nxor.nands):
         xor_nand.specialize(ic_nand)
 
+    nand_ic.add(F.has_schematic_hints(symbol_rotation=0))
+
     # connect power to IC
     nand_ic.power.connect(power_source.power)
 

pyproject.toml

@@ -207,11 +207,12 @@ exclude = [
     "node_modules",
     "venv",
 ]
-per-file-ignores = {}
-
 # Allow unused variables when underscore-prefixed.
 dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 
+[tool.ruff.lint.per-file-ignores]
+# SKiDL imported files are ignored because they use different linting rules to us
+"src/faebryk/exporters/schematic/kicad/skidl/*" = ["ALL"]
 
 [tool.ruff.lint.mccabe]
 # Unlike Flake8, default to a complexity level of 10.

src/faebryk/core/reference.py

@@ -17,16 +17,19 @@ class Reference[O: Node](constructed_field):
     class UnboundError(Exception):
         """Cannot resolve unbound reference"""
 
-    def __init__(self, out_type: type[O] | None = None):
+    def __init__(self, out_type: type[O] | None = None, optional: bool = False):
         self.gifs: dict[Node, GraphInterfaceReference] = defaultdict(
             GraphInterfaceReference
         )
         self.is_set: set[Node] = set()
+        self.optional = optional
 
         def get(instance: Node) -> O:
             try:
                 return cast(O, self.gifs[instance].get_reference())
             except GraphInterfaceReferenceUnboundError as ex:
+                if self.optional:
+                    return None
                 raise Reference.UnboundError from ex
 
         def set_(instance: Node, value: O):
@@ -39,6 +42,8 @@ def set_(instance: Node, value: O):
             self.is_set.add(instance)
 
             if out_type is not None and not isinstance(value, out_type):
+                if value is None and self.optional:
+                    return
                 raise TypeError(f"Expected {out_type} got {type(value)}")
 
             # attach our gif to what we're referring to
@@ -54,10 +59,12 @@ def __construct__(self, obj: Node) -> None:
         return None
 
 
-def reference[O: Node](out_type: type[O] | None = None) -> O | Reference:
+def reference[O: Node](
+    out_type: type[O] | None = None, optional: bool = False
+) -> O | Reference:
     """
     Create a simple reference to other nodes properly encoded in the graph.
 
     This final wrapper is primarily to fudge the typing.
     """
-    return Reference(out_type=out_type)
+    return Reference(out_type=out_type, optional=optional)

src/faebryk/exporters/netlist/graph.py

@@ -40,7 +40,8 @@ def get_or_set_name_and_value_of_node(c: Module):
                     c.get_full_name(),
                     type(c).__name__,
                     value,
-                )
+                ),
+                explicit=False,
             )
         )