Add utilities for BOM generation

src/faebryk/core/util.py

@@ -21,7 +21,7 @@
 from faebryk.library.has_overriden_name_defined import has_overriden_name_defined
 from faebryk.library.Range import Range
 from faebryk.library.Set import Set
-from faebryk.libs.util import NotNone, cast_assert
+from faebryk.libs.util import NotNone, cast_assert, round_str
 
 logger = logging.getLogger(__name__)
 T = TypeVar("T")
@@ -56,7 +56,6 @@ def unit_map(
 
     effective_mantissa = mantissa * (base**exponent_difference)
     round_digits = round(math.log(base, 10) * (1 - exponent_difference))
-    # print(f"{exponent_difference=}, {effective_mantissa=}, {round_digits=}")
 
     idx = available_exponent + start_idx
     rounded_mantissa = round(effective_mantissa, round_digits)
@@ -83,6 +82,15 @@ def as_unit(value: SupportsFloat, unit: str, base: int = 1000):
     return get_unit_prefix(value, base=base) + unit
 
 
+def as_unit_with_tolerance(param: Range | Constant, unit: str, base: int = 1000):
+    if isinstance(param, Constant):
+        return as_unit(param.value, unit, base=base) + " ± 0%"
+    center, delta = param.as_center_tuple()
+    delta_percent = delta / center * 100
+
+    return f"{as_unit(center, unit, base=base)} ± {round_str(delta_percent)}%"
+
+
 def get_all_nodes(node: Node, order_types=None) -> list[Node]:
     if order_types is None:
         order_types = []
@@ -96,9 +104,9 @@ def get_all_nodes(node: Node, order_types=None) -> list[Node]:
 
     out = sorted(
         out,
-        key=lambda x: order_types.index(type(x))
-        if type(x) in order_types
-        else len(order_types),
+        key=lambda x: (
+            order_types.index(type(x)) if type(x) in order_types else len(order_types)
+        ),
     )
 
     return out
@@ -241,7 +249,7 @@ def get_mif_tree(
 
 def format_mif_tree(tree: dict[ModuleInterface, dict[ModuleInterface, dict]]) -> str:
     def str_tree(
-        tree: dict[ModuleInterface, dict[ModuleInterface, dict]]
+        tree: dict[ModuleInterface, dict[ModuleInterface, dict]],
     ) -> dict[str, dict]:
         def get_name(k: ModuleInterface):
             # get_parent never none, since k gotten from parent

src/faebryk/library/Capacitor.py

@@ -5,15 +5,15 @@
 from enum import IntEnum, auto
 
 from faebryk.core.core import Module
-from faebryk.core.util import as_unit
+from faebryk.core.util import as_unit, as_unit_with_tolerance
 from faebryk.library.can_attach_to_footprint_symmetrically import (
     can_attach_to_footprint_symmetrically,
 )
 from faebryk.library.can_bridge_defined import can_bridge_defined
 from faebryk.library.Electrical import Electrical
 from faebryk.library.has_designator_prefix_defined import has_designator_prefix_defined
-from faebryk.library.has_simple_value_representation_based_on_param import (
-    has_simple_value_representation_based_on_param,
+from faebryk.library.has_simple_value_representation_based_on_params import (
+    has_simple_value_representation_based_on_params,
 )
 from faebryk.library.TBD import TBD
 from faebryk.libs.util import times
@@ -50,9 +50,15 @@ class _PARAMs(Module.PARAMS()):
         self.add_trait(can_bridge_defined(*self.IFs.unnamed))
 
         self.add_trait(
-            has_simple_value_representation_based_on_param(
-                self.PARAMs.capacitance,
-                lambda p: as_unit(p, "F"),
+            has_simple_value_representation_based_on_params(
+                (
+                    self.PARAMs.capacitance,
+                    self.PARAMs.rated_voltage,
+                    self.PARAMs.temperature_coefficient,
+                ),
+                lambda ps: f"{as_unit_with_tolerance(ps[0], 'F')} "
+                f"{as_unit(ps[1].max, 'V')} "
+                f"{ps[2].max.name}",
             )
         )
         self.add_trait(can_attach_to_footprint_symmetrically())

src/faebryk/library/Range.py

@@ -61,6 +61,9 @@ def contains(self, value_to_check: PV) -> bool:
     def as_tuple(self) -> tuple[PV, PV]:
         return (self.min, self.max)
 
+    def as_center_tuple(self) -> tuple[PV, PV]:
+        return (self.min + self.max) / 2, (self.max - self.min) / 2
+
     @classmethod
     def from_center(cls, center: PV, delta: PV) -> "Range[PV]":
         return cls(center - delta, center + delta)

src/faebryk/library/Resistor.py

@@ -4,15 +4,18 @@
 from math import sqrt
 
 from faebryk.core.core import Module, Parameter
-from faebryk.core.util import as_unit
+from faebryk.core.util import (
+    as_unit,
+    as_unit_with_tolerance,
+)
 from faebryk.library.can_attach_to_footprint_symmetrically import (
     can_attach_to_footprint_symmetrically,
 )
 from faebryk.library.can_bridge_defined import can_bridge_defined
 from faebryk.library.Electrical import Electrical
 from faebryk.library.has_designator_prefix_defined import has_designator_prefix_defined
-from faebryk.library.has_simple_value_representation_based_on_param import (
-    has_simple_value_representation_based_on_param,
+from faebryk.library.has_simple_value_representation_based_on_params import (
+    has_simple_value_representation_based_on_params,
 )
 from faebryk.library.TBD import TBD
 from faebryk.libs.util import times
@@ -30,14 +33,19 @@ class _IFs(super().IFS()):
 
         class PARAMS(super().PARAMS()):
             resistance = TBD[float]()
+            rated_power = TBD[float]()
 
         self.PARAMs = PARAMS(self)
 
         self.add_trait(can_attach_to_footprint_symmetrically())
         self.add_trait(
-            has_simple_value_representation_based_on_param(
-                self.PARAMs.resistance,
-                lambda p: as_unit(p, "Ω"),
+            has_simple_value_representation_based_on_params(
+                (
+                    self.PARAMs.resistance,
+                    self.PARAMs.rated_power,
+                ),
+                lambda ps: f"{as_unit_with_tolerance(ps[0], 'Ω')} "
+                f"{as_unit(ps[1].max, 'W')}",
             )
         )
         self.add_trait(has_designator_prefix_defined("R"))
@@ -101,3 +109,13 @@ def get_power_dissipation_by_voltage_current(
         voltage_drop_V: Parameter, current_A
     ) -> Parameter:
         return voltage_drop_V * current_A
+
+    def set_rated_power_by_voltage_resistance(self, voltage_drop_V: Parameter):
+        self.PARAMs.rated_power.merge(
+            self.get_power_dissipation_by_voltage_resistance(voltage_drop_V)
+        )
+
+    def set_rated_power_by_current_resistance(self, current_A: Parameter):
+        self.PARAMs.rated_power.merge(
+            self.get_power_dissipation_by_current_resistance(current_A)
+        )

src/faebryk/library/_F.py

@@ -122,6 +122,7 @@
 from faebryk.library.has_resistance import has_resistance
 from faebryk.library.has_simple_value_representation import has_simple_value_representation
 from faebryk.library.has_simple_value_representation_based_on_param import has_simple_value_representation_based_on_param
+from faebryk.library.has_simple_value_representation_based_on_params import has_simple_value_representation_based_on_params
 from faebryk.library.has_simple_value_representation_defined import has_simple_value_representation_defined
 from faebryk.library.has_single_connection import has_single_connection
 from faebryk.library.has_single_connection_impl import has_single_connection_impl

src/faebryk/library/has_simple_value_representation_based_on_params.py

@@ -0,0 +1,34 @@
+# This file is part of the faebryk project
+# SPDX-License-Identifier: MIT
+
+from typing import Callable, Sequence
+
+from faebryk.core.core import Parameter
+from faebryk.library.Constant import Constant
+from faebryk.library.has_simple_value_representation import (
+    has_simple_value_representation,
+)
+from faebryk.library.Range import Range
+
+
+class has_simple_value_representation_based_on_params(
+    has_simple_value_representation.impl()
+):
+    def __init__(
+        self,
+        params: Sequence[Parameter],
+        transformer: Callable[[Sequence[Constant | Range]], str],
+    ) -> None:
+        super().__init__()
+        self.transformer = transformer
+        self.params = params
+
+    def get_value(self) -> str:
+        params_const = tuple(param.get_most_narrow() for param in self.params)
+        assert all(isinstance(p, (Constant, Range)) for p in params_const)
+        return self.transformer(params_const)
+
+    def is_implemented(self):
+        return all(
+            isinstance(p.get_most_narrow(), (Range, Constant)) for p in self.params
+        )

src/faebryk/libs/util.py

@@ -12,6 +12,7 @@
     Iterator,
     List,
     Optional,
+    SupportsFloat,
     SupportsInt,
     Type,
     TypeVar,
@@ -226,8 +227,7 @@ def get_all(self) -> list[T]:
 
             return self._list
 
-        def handle_add(self, name: str, obj: T) -> None:
-            ...
+        def handle_add(self, name: str, obj: T) -> None: ...
 
         def get_parent(self) -> P:
             return self._parent
@@ -287,6 +287,11 @@ def is_type_set_subclasses(type_subclasses: set[type], types: set[type]) -> bool
     )
 
 
+def round_str(value: SupportsFloat, n=8):
+    f = round(float(value), n)
+    return str(f).rstrip("0").rstrip(".")
+
+
 def _print_stack(stack):
     from colorama import Fore