Export: KiCAD Schematic Transformer

src/faebryk/library/Symbol.py

@@ -0,0 +1,59 @@
+import faebryk.library._F as F
+from faebryk.core.module import Module
+from faebryk.core.moduleinterface import ModuleInterface
+from faebryk.core.reference import reference
+from faebryk.core.trait import Trait
+
+
+class Symbol(Module):
+    """
+    Symbols represent a symbol instance and are bi-directionally
+    linked with the module they represent via the `has_linked` trait.
+    """
+
+    class Pin(ModuleInterface):
+        represents = reference(F.Electrical)
+
+        class has_pin(F.has_reference.decless()):
+            """
+            Attach to an ElectricalInterface to point back at the pin
+            """
+
+            reference: "Symbol.Pin" = reference()
+
+    class TraitT(Trait): ...
+
+    class has_symbol(F.has_reference.decless()):
+        """
+        Attach to an Module to point back at the pin
+        """
+
+        reference: "Symbol" = reference()
+
+    class has_kicad_symbol(TraitT.decless()):
+        """
+        If a symbol has this trait, then the symbol has a matching KiCAD symbol
+        :param symbol_name: The full name of the KiCAD symbol including the library name
+        """
+
+        def __init__(self, symbol_name: str):
+            super().__init__()
+            self.symbol_name = symbol_name
+
+    pins: dict[str, Pin]
+    represents = reference(Module)
+
+    @classmethod
+    def with_component(cls, component: Module, pin_map: dict[str, ModuleInterface]):
+        sym = cls()
+        sym.represents = component
+        component.add(cls.has_symbol(sym))
+
+        sym.pins = {}
+        for pin_name, e_pin in pin_map.items():
+            pin = cls.Pin()
+            pin.represents = e_pin
+            e_pin.add(cls.Pin.has_pin(pin))
+            sym.pins[pin_name] = pin
+
+        return sym

src/faebryk/library/_F.py

@@ -31,6 +31,7 @@
 from faebryk.library.has_overriden_name import has_overriden_name
 from faebryk.library.Operation import Operation
 from faebryk.library.has_linked_pad import has_linked_pad
+from faebryk.library.has_reference import has_reference
 from faebryk.library.can_bridge import can_bridge
 from faebryk.library.has_designator import has_designator
 from faebryk.library.has_descriptive_properties import has_descriptive_properties
@@ -42,7 +43,6 @@
 from faebryk.library.has_picker import has_picker
 from faebryk.library.has_pcb_layout import has_pcb_layout
 from faebryk.library.has_pcb_routing_strategy import has_pcb_routing_strategy
-from faebryk.library.has_reference import has_reference
 from faebryk.library.has_resistance import has_resistance
 from faebryk.library.has_single_connection import has_single_connection
 from faebryk.library.is_representable_by_single_value import is_representable_by_single_value
@@ -72,6 +72,7 @@
 from faebryk.library.has_pcb_layout_defined import has_pcb_layout_defined
 from faebryk.library.has_single_connection_impl import has_single_connection_impl
 from faebryk.library.is_representable_by_single_value_defined import is_representable_by_single_value_defined
+from faebryk.library.Symbol import Symbol
 from faebryk.library.XtalIF import XtalIF
 from faebryk.library.has_pin_association_heuristic import has_pin_association_heuristic
 from faebryk.library.Common_Mode_Filter import Common_Mode_Filter
@@ -87,6 +88,7 @@
 from faebryk.library.Pad import Pad
 from faebryk.library.Button import Button
 from faebryk.library.GDT import GDT
+from faebryk.library.has_symbol_layout import has_symbol_layout
 from faebryk.library.has_pin_association_heuristic_lookup_table import has_pin_association_heuristic_lookup_table
 from faebryk.library.LogicGate import LogicGate
 from faebryk.library.has_footprint_defined import has_footprint_defined
@@ -95,6 +97,7 @@
 from faebryk.library.has_equal_pins import has_equal_pins
 from faebryk.library.has_kicad_manual_footprint import has_kicad_manual_footprint
 from faebryk.library.has_pcb_routing_strategy_greedy_direct_line import has_pcb_routing_strategy_greedy_direct_line
+from faebryk.library.has_symbol_layout_defined import has_symbol_layout_defined
 from faebryk.library.BJT import BJT
 from faebryk.library.Diode import Diode
 from faebryk.library.MOSFET import MOSFET

src/faebryk/library/has_symbol_layout.py

@@ -0,0 +1,8 @@
+# This file is part of the faebryk project
+# SPDX-License-Identifier: MIT
+
+import faebryk.library._F as F
+
+
+class has_symbol_layout(F.Symbol.TraitT):
+    translations: str

src/faebryk/library/has_symbol_layout_defined.py

@@ -0,0 +1,10 @@
+# This file is part of the faebryk project
+# SPDX-License-Identifier: MIT
+
+import faebryk.library._F as F
+
+
+class has_symbol_layout_defined(F.has_symbol_layout.impl()):
+    def __init__(self, translations: str = ""):
+        super().__init__()
+        self.translations = translations

src/faebryk/libs/kicad/fileformats_sch.py

@@ -1,8 +1,17 @@
+"""
+This module contains a dataclass representation of the KiCad file formats
+for schematic files (.kicad_sch).
+
+Rules:
+- Defaults are only allowed only with the values KiCAD itself defaults to
+"""
+
 import logging
 from dataclasses import dataclass, field
 from enum import auto
 from typing import Optional
 
+from faebryk.exporters.pcb.kicad.transformer import gen_uuid
 from faebryk.libs.kicad.fileformats_common import (
     UUID,
     C_effects,
@@ -17,6 +26,10 @@
 # TODO find complete examples of the fileformats, maybe in the kicad repo
 
 
+def uuid_field():
+    return field(default_factory=gen_uuid)
+
+
 @dataclass
 class C_property:
     name: str = field(**sexp_field(positional=True))
@@ -33,19 +46,24 @@ class C_fill:
     class E_type(SymEnum):
         background = "background"
         none = "none"
+        outline = "outline"
 
     type: E_type = field(default=E_type.background)
 
 
 @dataclass
 class C_stroke:
+    """
+    KiCAD default: (stroke (width 0) (type default) (color 0 0 0 0))
+    """
+
     class E_type(SymEnum):
         solid = auto()
         default = auto()
 
-    width: float
-    type: E_type
-    color: tuple[int, int, int, int]
+    width: float = 0
+    type: E_type = E_type.default
+    color: tuple[int, int, int, int] = (0, 0, 0, 0)
 
 
 @dataclass(kw_only=True)
@@ -185,28 +203,34 @@ class C_power:
                 pin_names: Optional[C_pin_names] = None
                 in_bom: Optional[bool] = None
                 on_board: Optional[bool] = None
-                symbols: list[C_symbol] = field(
-                    **sexp_field(multidict=True), default_factory=list
+                symbols: dict[str, C_symbol] = field(
+                    **sexp_field(multidict=True, key=lambda x: x.name),
+                    default_factory=dict,
                 )
                 convert: Optional[int] = None
 
-            symbol: dict[str, C_symbol] = field(
+            symbols: dict[str, C_symbol] = field(
                 **sexp_field(multidict=True, key=lambda x: x.name), default_factory=dict
             )
 
         @dataclass
         class C_symbol_instance:
+            """
+            TODO: Confusingly name, this isn't the class of
+            "symbol_instances" at the top-level of the .kicad_sch file
+            """
+
             @dataclass
             class C_pin:
-                uuid: UUID
-                pin: str = field(**sexp_field(positional=True))
+                name: str = field(**sexp_field(positional=True))
+                uuid: UUID = uuid_field()
 
             lib_id: str
-            uuid: UUID
             at: C_xyr
             unit: int
-            in_bom: bool
-            on_board: bool
+            in_bom: bool = False
+            on_board: bool = False
+            uuid: UUID = uuid_field()
             fields_autoplaced: bool = True
             propertys: dict[str, C_property] = field(
                 **sexp_field(multidict=True, key=lambda x: x.name),
@@ -222,20 +246,20 @@ class C_junction:
             at: C_xy
             diameter: float
             color: tuple[int, int, int, int]
-            uuid: UUID
+            uuid: UUID = uuid_field()
 
         @dataclass
         class C_wire:
             pts: C_pts
             stroke: C_stroke
-            uuid: UUID
+            uuid: UUID = uuid_field()
 
         @dataclass
         class C_text:
             at: C_xyr
             effects: C_effects
-            uuid: UUID
             text: str = field(**sexp_field(positional=True))
+            uuid: UUID = uuid_field()
 
         @dataclass
         class C_sheet:
@@ -251,15 +275,15 @@ class E_type(SymEnum):
 
                 at: C_xyr
                 effects: C_effects
-                uuid: UUID
                 name: str = field(**sexp_field(positional=True))
                 type: E_type = field(**sexp_field(positional=True))
+                uuid: UUID = uuid_field()
 
             at: C_xy
             size: C_xy
             stroke: C_stroke
             fill: C_fill
-            uuid: UUID
+            uuid: UUID = uuid_field()
             fields_autoplaced: bool = True
             propertys: dict[str, C_property] = field(
                 **sexp_field(multidict=True, key=lambda x: x.name),
@@ -286,8 +310,8 @@ class E_shape(SymEnum):
             shape: E_shape
             at: C_xyr
             effects: C_effects
-            uuid: UUID
             text: str = field(**sexp_field(positional=True))
+            uuid: UUID = uuid_field()
             fields_autoplaced: bool = True
             propertys: dict[str, C_property] = field(
                 **sexp_field(multidict=True, key=lambda x: x.name),
@@ -305,26 +329,26 @@ class E_shape(SymEnum):
         class C_label:
             at: C_xyr
             effects: C_effects
-            uuid: UUID
             text: str = field(**sexp_field(positional=True))
+            uuid: UUID = uuid_field()
 
         @dataclass
         class C_bus:
             pts: C_pts
             stroke: C_stroke
-            uuid: UUID
+            uuid: UUID = uuid_field()
 
         @dataclass
         class C_bus_entry:
             at: C_xy
             size: C_xy
             stroke: C_stroke
-            uuid: UUID
+            uuid: UUID = uuid_field()
 
         version: int = field(**sexp_field(assert_value=20211123))
         generator: str
-        uuid: UUID
         paper: str
+        uuid: UUID = uuid_field()
         lib_symbols: C_lib_symbols = field(default_factory=C_lib_symbols)
         title_block: C_title_block = field(default_factory=C_title_block)
 
@@ -354,4 +378,25 @@ class C_bus_entry:
             **sexp_field(multidict=True), default_factory=list
         )
 
+        # TODO: "symbol_instances" may or may not be required?
+        # It appears to be a list of all symbols used in the schematic
+        # But it also appears to be a translation of "symbols"
+
     kicad_sch: C_kicad_sch
+
+
+@dataclass
+class C_kicad_sym_file(SEXP_File):
+    """
+    When in doubt check: kicad/eeschema/sch_io/kicad_sexpr/sch_io_kicad_sexpr_parser.cpp
+    """
+
+    @dataclass
+    class C_kicad_symbol_lib:
+        version: int
+        generator: str
+        symbols: dict[str, C_kicad_sch_file.C_kicad_sch.C_lib_symbols.C_symbol] = field(
+            **sexp_field(multidict=True, key=lambda x: x.name), default_factory=dict
+        )
+
+    kicad_symbol_lib: C_kicad_symbol_lib

src/faebryk/libs/library/L.py

@@ -13,6 +13,7 @@
     list_field,
     rt_field,
 )
+from faebryk.core.reference import reference  # noqa: F401
 
 
 class AbstractclassError(Exception): ...

src/faebryk/libs/picker/lcsc.py

@@ -13,6 +13,7 @@
 )
 from easyeda2kicad.kicad.export_kicad_3d_model import Exporter3dModelKicad
 from easyeda2kicad.kicad.export_kicad_footprint import ExporterFootprintKicad
+from easyeda2kicad.kicad.export_kicad_symbol import ExporterSymbolKicad, KicadVersion
 
 import faebryk.library._F as F
 from faebryk.core.module import Module
@@ -112,17 +113,21 @@ def download_easyeda_info(partno: str, get_model: bool = True):
     # paths -------------------------------------------------------------------
     name = easyeda_footprint.info.name
     out_base_path = LIB_FOLDER
-    fp_base_path = out_base_path.joinpath("footprints/lcsc.pretty")
+    fp_base_path = out_base_path / "footprints" / "lcsc.pretty"
+    sym_base_path = out_base_path / "lcsc.kicad_sym"
     fp_base_path.mkdir(exist_ok=True, parents=True)
     footprint_filename = f"{name}.kicad_mod"
     footprint_filepath = fp_base_path.joinpath(footprint_filename)
 
-    model_base_path = out_base_path.joinpath("3dmodels/lcsc")
-    model_base_path_full = Path(model_base_path.as_posix() + ".3dshapes")
+    # The base_path has to be split from the full path, because the exporter
+    # will append .3dshapes to it
+    model_base_path = out_base_path / "3dmodels" / "lcsc"
+    model_base_path_full = model_base_path.with_suffix(".3dshapes")
     model_base_path_full.mkdir(exist_ok=True, parents=True)
 
     # export to kicad ---------------------------------------------------------
     ki_footprint = ExporterFootprintKicad(easyeda_footprint)
+    ki_symbol = ExporterSymbolKicad(easyeda_symbol, KicadVersion.v6)
 
     _fix_3d_model_offsets(ki_footprint)
 
@@ -135,7 +140,7 @@ def download_easyeda_info(partno: str, get_model: bool = True):
         ki_model = Exporter3dModelKicad(easyeda_model)
 
     if easyeda_model is not None:
-        model_path = model_base_path_full.joinpath(f"{easyeda_model.name}.wrl")
+        model_path = model_base_path_full / f"{easyeda_model.name}.wrl"
         if get_model and not model_path.exists():
             logger.debug(f"Downloading & Exporting 3dmodel {model_path}")
             easyeda_model = Easyeda3dModelImporter(
@@ -162,6 +167,10 @@ def download_easyeda_info(partno: str, get_model: bool = True):
             model_3d_path=kicad_model_path,
         )
 
+    if not sym_base_path.exists():
+        logger.debug(f"Exporting symbol {sym_base_path}")
+        ki_symbol.export(str(sym_base_path))
+
     return ki_footprint, ki_model, easyeda_footprint, easyeda_model, easyeda_symbol
 
 
@@ -194,6 +203,9 @@ def attach(component: Module, partno: str, get_model: bool = True):
                 raise LCSC_PinmapException(partno, f"Failed to get pinmap: {e}") from e
             component.add(F.can_attach_to_footprint_via_pinmap(pinmap))
 
+        sym = F.Symbol.with_component(component, pinmap)
+        sym.add(F.Symbol.has_kicad_symbol(f"lcsc:{easyeda_footprint.info.name}"))
+
         # footprint
         fp = F.KicadFootprint(
             f"lcsc:{easyeda_footprint.info.name}",