pyedb 0.2.0__py3-none-any.whl

pyedb/ipc2581/ecad/cad_data/logical_net.py

@@ -0,0 +1,32 @@
+from pyedb.generic.general_methods import ET
+
+
+class LogicalNet(object):
+    """Class describing an IPC2581 logical net."""
+
+    def __init__(self):
+        self.name = ""
+        self.pin_ref = []
+
+    def write_xml(self, step):  # pragma no cover
+        if step:
+            logical_net = ET.SubElement(step, "LogicalNet")
+            logical_net.set("name", self.name)
+            for pin in self.pin_ref:
+                pin.write_xml(logical_net)
+
+    def get_pin_ref_def(self):  # pragma no cover
+        return PinRef()
+
+
+class PinRef(object):
+    """Class describing an IPC2581 logical net."""
+
+    def __init__(self):
+        self.pin = ""
+        self.component_ref = ""
+
+    def write_xml(self, logical_net):  # pragma no cover
+        pin_ref = ET.SubElement(logical_net, "PinRef")
+        pin_ref.set("pin", self.pin)
+        pin_ref.set("componentRef", self.component_ref)

pyedb/ipc2581/ecad/cad_data/outline.py

@@ -0,0 +1,25 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.ecad.cad_data.polygon import Polygon
+
+
+class Outline:
+    """Class describing an IPC2581 outline."""
+
+    def __init__(self, ipc):
+        self._ipc = ipc
+        self.polygon = Polygon(self._ipc)
+        self.line_ref = ""
+
+    def write_xml(self, package):  # pragma no cover
+        outline = ET.SubElement(package, "Outline")
+        polygon = ET.SubElement(outline, "Polygon")
+        polygon_begin = ET.SubElement(polygon, "PolyBegin")
+        if self.polygon.poly_steps:
+            polygon_begin.set("x", str(self.polygon.poly_steps[0].x))
+            polygon_begin.set("y", str(self.polygon.poly_steps[0].y))
+            for poly_step in self.polygon.poly_steps[1:]:
+                polygon_segment = ET.SubElement(polygon, "PolyStepSegment")
+                polygon_segment.set("x", str(poly_step.x))
+                polygon_segment.set("y", str(poly_step.y))
+        line_desc_ref = ET.SubElement(outline, "LineDescRef")
+        line_desc_ref.set("id", self.line_ref)

pyedb/ipc2581/ecad/cad_data/package.py

@@ -0,0 +1,104 @@
+import math
+
+from pyedb.generic.general_methods import ET, pyedb_function_handler
+from pyedb.ipc2581.content.entry_line import EntryLine
+from pyedb.ipc2581.ecad.cad_data.assembly_drawing import AssemblyDrawing
+from pyedb.ipc2581.ecad.cad_data.outline import Outline
+from pyedb.ipc2581.ecad.cad_data.pin import Pin
+from pyedb.ipc2581.ecad.cad_data.polygon import PolyStep
+
+
+class Package(object):
+    """Class describing an IPC2581 package definition."""
+
+    def __init__(self, ipc):
+        self._ipc = ipc
+        self.name = ""
+        self.type = "OTHER"
+        self.pin_one = "1"
+        self.pin_orientation = "OTHER"
+        self.height = 0.1
+        self.assembly_drawing = AssemblyDrawing(self._ipc)
+        self.outline = Outline(self._ipc)
+        self._pins = []
+        self.pickup_point = [0.0, 0.0]
+
+    @property
+    def pins(self):
+        return self._pins
+
+    @pins.setter
+    def pins(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len([pin for pin in value if isinstance(pin, Pin)]) == len(value):
+                self._pins = value
+
+    @pyedb_function_handler()
+    def add_pin(self, number=0, x=0.0, y=0.0, rotation=0.0, primitive_ref=""):  # pragma no cover
+        added_pin = Pin()
+        added_pin.x = x
+        added_pin.y = y
+        added_pin.rotation = rotation * 180 / math.pi
+        added_pin.number = number
+        added_pin.primitive_def = primitive_ref
+        self.pins.append(added_pin)
+
+    @pyedb_function_handler()
+    def add_component_outline(self, component):  # pragma no cover
+        if component:
+            _bbox = component.bounding_box
+            _rot = component.rotation
+            average_x = (_bbox[0] + _bbox[2]) / 2
+            average_y = (_bbox[1] + _bbox[3]) / 2
+            bb1x = _bbox[0] - average_x
+            bb1y = _bbox[1] - average_y
+            bb2x = _bbox[2] - average_x
+            bb2y = _bbox[3] - average_y
+
+            bb1x_rot = bb1x
+            bb2x_rot = bb2x
+            bb1y_rot = bb1y
+            bb2y_rot = bb2y
+            if _rot >= math.pi / 4 and _rot <= 0.75 * math.pi:
+                bb = bb1x_rot
+                bb1x_rot = bb1y_rot
+                bb1y_rot = bb
+                bb = bb2x_rot
+                bb2x_rot = bb2y_rot
+                bb2y_rot = bb
+            poly_step1 = PolyStep()
+            poly_step2 = PolyStep()
+            poly_step3 = PolyStep()
+            poly_step4 = PolyStep()
+            poly_step5 = PolyStep()
+            poly_step1.x = str(self._ipc.from_meter_to_units(bb1x_rot, self._ipc.units))
+            poly_step1.y = str(self._ipc.from_meter_to_units(bb1y_rot, self._ipc.units))
+            poly_step2.x = str(self._ipc.from_meter_to_units(bb2x_rot, self._ipc.units))
+            poly_step2.y = str(self._ipc.from_meter_to_units(bb1y_rot, self._ipc.units))
+            poly_step3.x = str(self._ipc.from_meter_to_units(bb2x_rot, self._ipc.units))
+            poly_step3.y = str(self._ipc.from_meter_to_units(bb2y_rot, self._ipc.units))
+            poly_step4.x = str(self._ipc.from_meter_to_units(bb1x_rot, self._ipc.units))
+            poly_step4.y = str(self._ipc.from_meter_to_units(bb2y_rot, self._ipc.units))
+            poly_step5.x = str(self._ipc.from_meter_to_units(bb1x_rot, self._ipc.units))
+            poly_step5.y = str(self._ipc.from_meter_to_units(bb1y_rot, self._ipc.units))
+            self.outline.polygon.poly_steps = [poly_step1, poly_step2, poly_step3, poly_step4, poly_step5]
+            if not "ROUND_0" in self._ipc.content.dict_line.dict_lines:
+                entry_line = EntryLine()
+                entry_line.line_width = 0.0
+                self._ipc.content.dict_line.dict_lines["ROUND_0"] = entry_line
+            self.outline.line_ref = "ROUND_0"
+            self.assembly_drawing.polygon.poly_steps = [poly_step1, poly_step2, poly_step3, poly_step4, poly_step5]
+            self.assembly_drawing.line_ref = "ROUND_0"
+
+    @pyedb_function_handler()
+    def write_xml(self, step):  # pragma no cover
+        package = ET.SubElement(step, "Package")
+        package.set("name", self.name)
+        package.set("type", self.type)
+        package.set("pinOne", self.pin_one)
+        package.set("pinOneOrientation", self.pin_orientation)
+        package.set("height", str(self.height))
+        self.outline.write_xml(package)
+        self.assembly_drawing.write_xml(package)
+        for pin in self.pins:
+            pin.write_xml(package)

pyedb/ipc2581/ecad/cad_data/padstack_def.py

@@ -0,0 +1,38 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.ecad.cad_data.padstack_hole_def import PadstackHoleDef
+from pyedb.ipc2581.ecad.cad_data.padstack_pad_def import PadstackPadDef
+
+
+class PadstackDef(object):
+    """Class describing an IPC2581 padstack definition."""
+
+    def __init__(self):
+        self.name = ""
+        self.padstack_hole_def = PadstackHoleDef()
+        self._padstack_pad_def = []
+
+    @property
+    def padstack_pad_def(self):
+        return self._padstack_pad_def
+
+    @padstack_pad_def.setter
+    def padstack_pad_def(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len([pad for pad in value if isinstance(pad, PadstackPadDef)]) == len(value):
+                self._padstack_pad_def = value
+
+    def add_padstack_pad_def(self, layer="", pad_use="REGULAR", x="0", y="0", primitive_ref=""):  # pragma no cover
+        pad = PadstackPadDef()
+        pad.layer_ref = layer
+        pad.pad_use = pad_use
+        pad.x = x
+        pad.y = y
+        pad.primitive_ref = primitive_ref
+        self.padstack_pad_def.append(pad)
+
+    def write_xml(self, step):  # pragma no cover
+        padstack_def = ET.SubElement(step, "PadStackDef")
+        padstack_def.set("name", self.name)
+        self.padstack_hole_def.write_xml(padstack_def)
+        for pad in self.padstack_pad_def:
+            pad.write_xml(padstack_def)

pyedb/ipc2581/ecad/cad_data/padstack_hole_def.py

@@ -0,0 +1,24 @@
+from pyedb.generic.general_methods import ET
+
+
+class PadstackHoleDef(object):
+    """Class describing an ICP2581 padstack hole definition."""
+
+    def __init__(self):
+        self.name = ""
+        self.diameter = 0
+        self.plating_status = "PLATED"
+        self.plus_tol = 0
+        self.minus_tol = 0
+        self.x = 0
+        self.y = 0
+
+    def write_xml(self, padstackdef):  # pragma no cover
+        padstack_hole = ET.SubElement(padstackdef, "PadstackHoleDef")
+        padstack_hole.set("name", self.name)
+        padstack_hole.set("diameter", str(self.diameter))
+        padstack_hole.set("platingStatus", str(self.plating_status))
+        padstack_hole.set("plusTol", str(self.plus_tol))
+        padstack_hole.set("minusTol", str(self.minus_tol))
+        padstack_hole.set("x", str(self.x))
+        padstack_hole.set("y", str(self.y))

pyedb/ipc2581/ecad/cad_data/padstack_instance.py

@@ -0,0 +1,62 @@
+from pyedb.generic.general_methods import ET
+
+
+class PadstackInstance(object):
+    """Class describing an IPC2581 padstack instance."""
+
+    def __init__(self):
+        self.isvia = False
+        self.padstack_def = ""
+        self.standard_primimtive_ref = ""
+        self.pin = ""
+        self.x = ""
+        self.y = ""
+        self.rotation = ""
+        self.refdes = ""
+        self.net = ""
+        self.mirror = False
+
+    def write_xml(self, net_root):  # pragma no cover
+        if self.isvia:
+            net_root.set("testPoint", "false")
+            net_root.set("plate", "true")
+            net_root.set("padUsage", "VIA")
+            non_standard_attribute = ET.SubElement(net_root, "NonstandardAttribute")
+            non_standard_attribute.set("name", "PADSTACK_USAGE")
+            non_standard_attribute.set("value", "Through")
+            non_standard_attribute.set("type", "STRING")
+            pad = ET.SubElement(net_root, "Pad")
+            pad.set("padstackDefRef", self.padstack_def)
+            xform = ET.SubElement(pad, "Xform")
+            xform.set("rotation", "0")
+            xform.set("mirror", str(self.mirror).lower())
+            location = ET.SubElement(pad, "Location")
+            location.set("x", str(self.x))
+            location.set("y", str(self.y))
+            primitive_ref = ET.SubElement(pad, "StandardPrimitiveRef")
+            primitive_ref.set("id", self.standard_primimtive_ref)
+            if self.refdes:
+                pin_ref = ET.SubElement(pad, "PinRef")
+                pin_ref.set("pin", self.pin)
+                pin_ref.set("componentRef", self.refdes)
+        else:
+            net_root.set("testPoint", "false")
+            net_root.set("plate", "true")
+            non_standard_attribute = ET.SubElement(net_root, "NonstandardAttribute")
+            non_standard_attribute.set("name", "PADSTACK_USAGE")
+            non_standard_attribute.set("value", "Through")
+            non_standard_attribute.set("type", "STRING")
+            pad = ET.SubElement(net_root, "Pad")
+            pad.set("padstackDefRef", self.padstack_def)
+            xform = ET.SubElement(pad, "Xform")
+            xform.set("rotation", str(self.rotation))
+            xform.set("mirror", str(self.mirror).lower())
+            location = ET.SubElement(pad, "Location")
+            location.set("x", str(self.x))
+            location.set("y", str(self.y))
+            primitive_ref = ET.SubElement(pad, "StandardPrimitiveRef")
+            primitive_ref.set("id", self.standard_primimtive_ref)
+            if self.refdes:
+                pin_ref = ET.SubElement(pad, "PinRef")
+                pin_ref.set("pin", self.pin)
+                pin_ref.set("componentRef", self.refdes)

pyedb/ipc2581/ecad/cad_data/padstack_pad_def.py

@@ -0,0 +1,26 @@
+from pyedb.generic.general_methods import ET
+
+
+class PadstackPadDef(object):
+    """Class describing an IPC2581 padstack definition."""
+
+    def __init__(self):
+        self.layer_ref = ""
+        self.pad_use = "REGULAR"
+        self.x = 0.0
+        self.y = 0.0
+        self.primitive_ref = "CIRCLE_DEFAULT"
+
+    def write_xml(self, padstack_def):  # pragma no cover
+        pad_def = ET.SubElement(padstack_def, "PadstackPadDef")
+        pad_def.set("layerRef", self.layer_ref)
+        pad_def.set("padUse", self.pad_use)
+        location = ET.SubElement(pad_def, "Location")
+        location.set("x", str(self.x))
+        location.set("y", str(self.y))
+        standard_primitive = ET.SubElement(pad_def, "StandardPrimitiveRef")
+        standard_primitive.set("id", self.primitive_ref)
+
+
+class PadUse(object):
+    (Regular, Antipad, Thermal) = range(0, 3)

pyedb/ipc2581/ecad/cad_data/path.py

@@ -0,0 +1,89 @@
+from pyedb.generic.general_methods import ET, pyedb_function_handler
+from pyedb.ipc2581.content.entry_line import EntryLine
+from pyedb.ipc2581.ecad.cad_data.polygon import PolyStep, PolyType
+
+
+class Path(object):
+    """Class describing an IPC2581 trace."""
+
+    def __init__(self, ipc):
+        self._ipc = ipc
+        self.location_x = 0.0
+        self.location_y = 0.0
+        self.poly_steps = []
+        self.entry_line = EntryLine()
+        self.width_ref_id = ""
+
+    @pyedb_function_handler()
+    def add_path_step(self, path_step=None):  # pragma no cover
+        arcs = path_step.primitive_object.GetCenterLine().GetArcData()
+        if not arcs:
+            return
+        self.line_width = self._ipc.from_meter_to_units(path_step.primitive_object.GetWidth(), self._ipc.units)
+        self.width_ref_id = "ROUND_{}".format(self.line_width)
+        if not self.width_ref_id in self._ipc.content.dict_line.dict_lines:
+            entry_line = EntryLine()
+            entry_line.line_width = self.line_width
+            self._ipc.content.dict_line.dict_lines[self.width_ref_id] = entry_line
+        # first point
+        arc = arcs[0]
+        new_segment_tep = PolyStep()
+        new_segment_tep.x = arc.Start.X.ToDouble()
+        new_segment_tep.y = arc.Start.Y.ToDouble()
+        self.poly_steps.append(new_segment_tep)
+        if arc.Height == 0:
+            new_segment_tep = PolyStep()
+            new_segment_tep.poly_type = PolyType.Segment
+            new_segment_tep.x = arc.End.X.ToDouble()
+            new_segment_tep.y = arc.End.Y.ToDouble()
+            self.poly_steps.append(new_segment_tep)
+        else:
+            arc_center = arc.GetCenter()
+            new_poly_step = PolyStep()
+            new_poly_step.poly_type = PolyType.Curve
+            new_poly_step.center_X = arc_center.X.ToDouble()
+            new_poly_step.center_y = arc_center.Y.ToDouble()
+            new_poly_step.x = arc.End.X.ToDouble()
+            new_poly_step.y = arc.End.Y.ToDouble()
+            new_poly_step.clock_wise = not arc.IsCCW()
+            self.poly_steps.append(new_poly_step)
+        for arc in list(arcs)[1:]:
+            if arc.Height == 0:
+                new_segment_tep = PolyStep()
+                new_segment_tep.poly_type = PolyType.Segment
+                new_segment_tep.x = arc.End.X.ToDouble()
+                new_segment_tep.y = arc.End.Y.ToDouble()
+                self.poly_steps.append(new_segment_tep)
+            else:
+                arc_center = arc.GetCenter()
+                new_poly_step = PolyStep()
+                new_poly_step.poly_type = PolyType.Curve
+                new_poly_step.center_X = arc_center.X.ToDouble()
+                new_poly_step.center_y = arc_center.Y.ToDouble()
+                new_poly_step.x = arc.End.X.ToDouble()
+                new_poly_step.y = arc.End.Y.ToDouble()
+                new_poly_step.clock_wise = not arc.IsCCW()
+                self.poly_steps.append(new_poly_step)
+
+    @pyedb_function_handler()
+    def write_xml(self, net_root):  # pragma no cover
+        if not self.poly_steps:
+            return
+        feature = ET.SubElement(net_root, "Features")
+        location = ET.SubElement(feature, "Location")
+        location.set("x", "0")
+        location.set("y", "0")
+        polyline = ET.SubElement(feature, "Polyline")
+        polyline_begin = ET.SubElement(polyline, "PolyBegin")
+        polyline_begin.set("x", str(self._ipc.from_meter_to_units(self.poly_steps[0].x, self._ipc.units)))
+        polyline_begin.set("y", str(self._ipc.from_meter_to_units(self.poly_steps[0].y, self._ipc.units)))
+        for poly_step in self.poly_steps[1:]:
+            poly_step.write_xml(polyline, self._ipc)
+        line_disc_ref = ET.SubElement(polyline, "LineDescRef")
+        line_disc_ref.set("id", self.width_ref_id)
+
+
+class PathStep(object):
+    def __init__(self):
+        self.x = 0.0
+        self.y = 0.0

pyedb/ipc2581/ecad/cad_data/phy_net.py

@@ -0,0 +1,80 @@
+from pyedb.generic.general_methods import ET
+
+
+class PhyNet(object):
+    """Class describing an IPC2581 physical net."""
+
+    def __init__(self):
+        self._name = ""
+        self._phy_net_points = []
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, value):  # pragma no cover
+        if isinstance(value, str):
+            self._name = value
+
+    @property
+    def phy_net_points(self):
+        return self._phy_net_points
+
+    @phy_net_points.setter
+    def phy_net_points(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len([net for net in value if isinstance(net, PhyNetPoint)]) == len(value):
+                self._phy_net_points = value
+
+    def add_phy_net_point(self, point=None):  # pragma no cover
+        if isinstance(point, PhyNetPoint):
+            self._phy_net_points.append(point)
+
+    def write_xml(self, step):  # pragma no cover
+        if step:
+            phy_net = ET.SubElement(step, "PhyNet")
+            for phy_net_point in self.phy_net_points:
+                phy_net_point.write_xml(phy_net)
+
+
+class PhyNetPoint(object):
+    """Class describing an IPC2581 physical net point."""
+
+    def __init__(self):
+        self.x = 0.0
+        self.y = 0.0
+        self.layer_ref = ""
+        self.net_node_type = ""
+        self._exposure = ExposureType().Exposed
+        self.via = ""
+        self.standard_primitive_id = ""
+
+    @property
+    def exposure(self):
+        if self._exposure == ExposureType.Exposed:
+            return "EXPOSED"
+        elif self._exposure == ExposureType.CoveredPrimary:
+            return "COVERED_PRIMARY"
+        elif self._exposure == ExposureType.CoveredSecondary:
+            return "COVERED_SECONDARY"
+
+    def write_xml(self, phynet):  # pragma no cover
+        if phynet:
+            phynet_point = ET.SubElement(phynet, "PhyNetPoint")
+            phynet_point.set("x", self.x)
+            phynet_point.set("y", self.y)
+            phynet_point.set("layerRef", self.layer_ref)
+            phynet_point.set("netNode", self.net_node_type)
+            phynet_point.set("exposure", self.exposure)
+            phynet_point.set("via", self.via)
+            primitive_ref = ET.SubElement(phynet_point, "StandardPrimitiveRef")
+            primitive_ref.set("id", self.standard_primitive_id)
+
+
+class NetNodeType(object):
+    (Middle, End) = range(0, 2)
+
+
+class ExposureType(object):
+    (CoveredPrimary, CoveredSecondary, Exposed) = range(0, 3)

pyedb/ipc2581/ecad/cad_data/pin.py

@@ -0,0 +1,31 @@
+from pyedb.generic.general_methods import ET
+
+
+class Pin(object):
+    """Class describing an ICP2581 component pin."""
+
+    def __init__(self):
+        self.number = ""
+        self.electrical_type = "ELECTRICAL"
+        self.x = 0.0
+        self.y = 0.0
+        self.rotation = 0.0
+        self.primitive_def = ""
+        self.is_via = False
+
+    def write_xml(self, package):  # pragma no cover
+        pin = ET.SubElement(package, "Pin")
+        pin.set("number", str(self.number))
+        pin.set("type", "THRU")
+        pin.set("electricalType", self.electrical_type)
+        xform = ET.SubElement(pin, "Xform")
+        xform.set("rotation", str(self.rotation))
+        location = ET.SubElement(pin, "Location")
+        location.set("x", str(self.x))
+        location.set("y", str(self.y))
+        primitive_ref = ET.SubElement(pin, "StandardPrimitiveRef")
+        primitive_ref.set("id", self.primitive_def)
+
+
+class Type(object):
+    (Thru, Surface) = range(0, 2)