844 lines
31 KiB
Python
844 lines
31 KiB
Python
import os
|
|
from datetime import datetime
|
|
|
|
import pcbnew
|
|
|
|
from .common import EcadParser, Component, ExtraFieldData
|
|
from .kicad_extra import find_latest_schematic_data, parse_schematic_data
|
|
from .svgpath import create_path
|
|
from ..core import ibom
|
|
from ..core.config import Config
|
|
from ..core.fontparser import FontParser
|
|
|
|
|
|
class PcbnewParser(EcadParser):
|
|
|
|
def __init__(self, file_name, config, logger, board=None):
|
|
super(PcbnewParser, self).__init__(file_name, config, logger)
|
|
self.board = board
|
|
if self.board is None:
|
|
self.board = pcbnew.LoadBoard(self.file_name) # type: pcbnew.BOARD
|
|
if hasattr(self.board, 'GetModules'):
|
|
self.footprints = list(self.board.GetModules())
|
|
else:
|
|
self.footprints = list(self.board.GetFootprints())
|
|
self.font_parser = FontParser()
|
|
|
|
def get_extra_field_data(self, file_name):
|
|
if os.path.abspath(file_name) == os.path.abspath(self.file_name):
|
|
return self.parse_extra_data_from_pcb()
|
|
if os.path.splitext(file_name)[1] == '.kicad_pcb':
|
|
return None
|
|
|
|
data = parse_schematic_data(file_name)
|
|
|
|
return ExtraFieldData(data[0], data[1])
|
|
|
|
@staticmethod
|
|
def get_footprint_fields(f):
|
|
# type: (pcbnew.FOOTPRINT) -> dict
|
|
props = {}
|
|
if hasattr(f, "GetProperties"):
|
|
props = f.GetProperties()
|
|
if hasattr(f, "GetFields"):
|
|
props = f.GetFieldsShownText()
|
|
if "dnp" in props and props["dnp"] == "":
|
|
del props["dnp"]
|
|
props["kicad_dnp"] = "DNP"
|
|
if hasattr(f, "IsDNP"):
|
|
if f.IsDNP():
|
|
props["kicad_dnp"] = "DNP"
|
|
return props
|
|
|
|
def parse_extra_data_from_pcb(self):
|
|
field_set = set()
|
|
by_ref = {}
|
|
by_index = {}
|
|
|
|
for (i, f) in enumerate(self.footprints):
|
|
props = self.get_footprint_fields(f)
|
|
by_index[i] = props
|
|
ref = f.GetReference()
|
|
ref_fields = by_ref.setdefault(ref, {})
|
|
|
|
for k, v in props.items():
|
|
field_set.add(k)
|
|
ref_fields[k] = v
|
|
|
|
return ExtraFieldData(list(field_set), by_ref, by_index)
|
|
|
|
def latest_extra_data(self, extra_dirs=None):
|
|
base_name = os.path.splitext(os.path.basename(self.file_name))[0]
|
|
extra_dirs.append(self.board.GetPlotOptions().GetOutputDirectory())
|
|
file_dir_name = os.path.dirname(self.file_name)
|
|
directories = [file_dir_name]
|
|
for dir in extra_dirs:
|
|
if not os.path.isabs(dir):
|
|
dir = os.path.join(file_dir_name, dir)
|
|
if os.path.exists(dir):
|
|
directories.append(dir)
|
|
return find_latest_schematic_data(base_name, directories)
|
|
|
|
def extra_data_file_filter(self):
|
|
if hasattr(self.board, 'GetModules'):
|
|
return "Netlist and xml files (*.net; *.xml)|*.net;*.xml"
|
|
else:
|
|
return ("Netlist, xml and pcb files (*.net; *.xml; *.kicad_pcb)|"
|
|
"*.net;*.xml;*.kicad_pcb")
|
|
|
|
@staticmethod
|
|
def normalize(point):
|
|
return [point.x * 1e-6, point.y * 1e-6]
|
|
|
|
@staticmethod
|
|
def normalize_angle(angle):
|
|
if isinstance(angle, int) or isinstance(angle, float):
|
|
return angle * 0.1
|
|
else:
|
|
return angle.AsDegrees()
|
|
|
|
def get_arc_angles(self, d):
|
|
# type: (pcbnew.PCB_SHAPE) -> tuple
|
|
a1 = self.normalize_angle(d.GetArcAngleStart())
|
|
if hasattr(d, "GetAngle"):
|
|
a2 = a1 + self.normalize_angle(d.GetAngle())
|
|
else:
|
|
a2 = a1 + self.normalize_angle(d.GetArcAngle())
|
|
if a2 < a1:
|
|
a1, a2 = a2, a1
|
|
return round(a1, 2), round(a2, 2)
|
|
|
|
def parse_shape(self, d):
|
|
# type: (pcbnew.PCB_SHAPE) -> dict or None
|
|
shape = {
|
|
pcbnew.S_SEGMENT: "segment",
|
|
pcbnew.S_CIRCLE: "circle",
|
|
pcbnew.S_ARC: "arc",
|
|
pcbnew.S_POLYGON: "polygon",
|
|
pcbnew.S_CURVE: "curve",
|
|
pcbnew.S_RECT: "rect",
|
|
}.get(d.GetShape(), "")
|
|
if shape == "":
|
|
self.logger.info("Unsupported shape %s, skipping", d.GetShape())
|
|
return None
|
|
start = self.normalize(d.GetStart())
|
|
end = self.normalize(d.GetEnd())
|
|
if shape == "segment":
|
|
return {
|
|
"type": shape,
|
|
"start": start,
|
|
"end": end,
|
|
"width": d.GetWidth() * 1e-6
|
|
}
|
|
|
|
if shape == "rect":
|
|
if hasattr(d, "GetRectCorners"):
|
|
points = list(map(self.normalize, d.GetRectCorners()))
|
|
else:
|
|
points = [
|
|
start,
|
|
[end[0], start[1]],
|
|
end,
|
|
[start[0], end[1]]
|
|
]
|
|
shape_dict = {
|
|
"type": "polygon",
|
|
"pos": [0, 0],
|
|
"angle": 0,
|
|
"polygons": [points],
|
|
"width": d.GetWidth() * 1e-6,
|
|
"filled": 0
|
|
}
|
|
if hasattr(d, "IsFilled") and d.IsFilled():
|
|
shape_dict["filled"] = 1
|
|
return shape_dict
|
|
|
|
if shape == "circle":
|
|
shape_dict = {
|
|
"type": shape,
|
|
"start": start,
|
|
"radius": d.GetRadius() * 1e-6,
|
|
"width": d.GetWidth() * 1e-6
|
|
}
|
|
if hasattr(d, "IsFilled") and d.IsFilled():
|
|
shape_dict["filled"] = 1
|
|
return shape_dict
|
|
|
|
if shape == "arc":
|
|
a1, a2 = self.get_arc_angles(d)
|
|
if hasattr(d, "GetCenter"):
|
|
start = self.normalize(d.GetCenter())
|
|
return {
|
|
"type": shape,
|
|
"start": start,
|
|
"radius": d.GetRadius() * 1e-6,
|
|
"startangle": a1,
|
|
"endangle": a2,
|
|
"width": d.GetWidth() * 1e-6
|
|
}
|
|
|
|
if shape == "polygon":
|
|
if hasattr(d, "GetPolyShape"):
|
|
polygons = self.parse_poly_set(d.GetPolyShape())
|
|
else:
|
|
self.logger.info(
|
|
"Polygons not supported for KiCad 4, skipping")
|
|
return None
|
|
angle = 0
|
|
if hasattr(d, 'GetParentModule'):
|
|
parent_footprint = d.GetParentModule()
|
|
else:
|
|
parent_footprint = d.GetParentFootprint()
|
|
if parent_footprint is not None:
|
|
angle = self.normalize_angle(parent_footprint.GetOrientation())
|
|
shape_dict = {
|
|
"type": shape,
|
|
"pos": start,
|
|
"angle": angle,
|
|
"polygons": polygons
|
|
}
|
|
if hasattr(d, "IsFilled") and not d.IsFilled():
|
|
shape_dict["filled"] = 0
|
|
shape_dict["width"] = d.GetWidth() * 1e-6
|
|
return shape_dict
|
|
if shape == "curve":
|
|
if hasattr(d, "GetBezierC1"):
|
|
c1 = self.normalize(d.GetBezierC1())
|
|
c2 = self.normalize(d.GetBezierC2())
|
|
else:
|
|
c1 = self.normalize(d.GetBezControl1())
|
|
c2 = self.normalize(d.GetBezControl2())
|
|
return {
|
|
"type": shape,
|
|
"start": start,
|
|
"cpa": c1,
|
|
"cpb": c2,
|
|
"end": end,
|
|
"width": d.GetWidth() * 1e-6
|
|
}
|
|
|
|
def parse_line_chain(self, shape):
|
|
# type: (pcbnew.SHAPE_LINE_CHAIN) -> list
|
|
result = []
|
|
if not hasattr(shape, "PointCount"):
|
|
self.logger.warn("No PointCount method on outline object. "
|
|
"Unpatched kicad version?")
|
|
return result
|
|
|
|
for point_index in range(shape.PointCount()):
|
|
result.append(
|
|
self.normalize(shape.CPoint(point_index)))
|
|
|
|
return result
|
|
|
|
def parse_poly_set(self, poly):
|
|
# type: (pcbnew.SHAPE_POLY_SET) -> list
|
|
result = []
|
|
|
|
for i in range(poly.OutlineCount()):
|
|
result.append(self.parse_line_chain(poly.Outline(i)))
|
|
|
|
return result
|
|
|
|
def parse_text(self, d):
|
|
# type: (pcbnew.PCB_TEXT) -> dict
|
|
if not d.IsVisible() and d.GetClass() not in ["PTEXT", "PCB_TEXT"]:
|
|
return None
|
|
pos = self.normalize(d.GetPosition())
|
|
if hasattr(d, "GetTextThickness"):
|
|
thickness = d.GetTextThickness() * 1e-6
|
|
else:
|
|
thickness = d.GetThickness() * 1e-6
|
|
if hasattr(d, 'TransformToSegmentList'):
|
|
segments = [self.normalize(p) for p in d.TransformToSegmentList()]
|
|
lines = []
|
|
for i in range(0, len(segments), 2):
|
|
if i == 0 or segments[i - 1] != segments[i]:
|
|
lines.append([segments[i]])
|
|
lines[-1].append(segments[i + 1])
|
|
return {
|
|
"thickness": thickness,
|
|
"svgpath": create_path(lines)
|
|
}
|
|
elif hasattr(d, 'GetEffectiveTextShape'):
|
|
shape = d.GetEffectiveTextShape(False) # type: pcbnew.SHAPE_COMPOUND
|
|
segments = []
|
|
polygons = []
|
|
for s in shape.GetSubshapes():
|
|
if s.Type() == pcbnew.SH_LINE_CHAIN:
|
|
polygons.append(self.parse_line_chain(s))
|
|
elif s.Type() == pcbnew.SH_SEGMENT:
|
|
seg = s.GetSeg()
|
|
segments.append(
|
|
[self.normalize(seg.A), self.normalize(seg.B)])
|
|
else:
|
|
self.logger.warn(
|
|
"Unsupported subshape in text: %s" % s.Type())
|
|
if segments:
|
|
return {
|
|
"thickness": thickness,
|
|
"svgpath": create_path(segments)
|
|
}
|
|
else:
|
|
return {
|
|
"polygons": polygons
|
|
}
|
|
|
|
if d.GetClass() == "MTEXT":
|
|
angle = self.normalize_angle(d.GetDrawRotation())
|
|
else:
|
|
if hasattr(d, "GetTextAngle"):
|
|
angle = self.normalize_angle(d.GetTextAngle())
|
|
else:
|
|
angle = self.normalize_angle(d.GetOrientation())
|
|
if hasattr(d, "GetTextHeight"):
|
|
height = d.GetTextHeight() * 1e-6
|
|
width = d.GetTextWidth() * 1e-6
|
|
else:
|
|
height = d.GetHeight() * 1e-6
|
|
width = d.GetWidth() * 1e-6
|
|
if hasattr(d, "GetShownText"):
|
|
text = d.GetShownText()
|
|
else:
|
|
text = d.GetText()
|
|
self.font_parser.parse_font_for_string(text)
|
|
attributes = []
|
|
if d.IsMirrored():
|
|
attributes.append("mirrored")
|
|
if d.IsItalic():
|
|
attributes.append("italic")
|
|
if d.IsBold():
|
|
attributes.append("bold")
|
|
|
|
return {
|
|
"pos": pos,
|
|
"text": text,
|
|
"height": height,
|
|
"width": width,
|
|
"justify": [d.GetHorizJustify(), d.GetVertJustify()],
|
|
"thickness": thickness,
|
|
"attr": attributes,
|
|
"angle": angle
|
|
}
|
|
|
|
def parse_dimension(self, d):
|
|
# type: (pcbnew.PCB_DIMENSION_BASE) -> dict
|
|
segments = []
|
|
circles = []
|
|
for s in d.GetShapes():
|
|
s = s.Cast()
|
|
if s.Type() == pcbnew.SH_SEGMENT:
|
|
seg = s.GetSeg()
|
|
segments.append(
|
|
[self.normalize(seg.A), self.normalize(seg.B)])
|
|
elif s.Type() == pcbnew.SH_CIRCLE:
|
|
circles.append(
|
|
[self.normalize(s.GetCenter()), s.GetRadius() * 1e-6])
|
|
else:
|
|
self.logger.info(
|
|
"Unsupported shape type in dimension object: %s", s.Type())
|
|
|
|
svgpath = create_path(segments, circles=circles)
|
|
|
|
return {
|
|
"thickness": d.GetLineThickness() * 1e-6,
|
|
"svgpath": svgpath
|
|
}
|
|
|
|
def parse_drawing(self, d):
|
|
# type: (pcbnew.BOARD_ITEM) -> list
|
|
result = []
|
|
s = None
|
|
if d.GetClass() in ["DRAWSEGMENT", "MGRAPHIC", "PCB_SHAPE"]:
|
|
s = self.parse_shape(d)
|
|
elif d.GetClass() in ["PTEXT", "MTEXT", "FP_TEXT", "PCB_TEXT", "PCB_FIELD"]:
|
|
s = self.parse_text(d)
|
|
elif (d.GetClass().startswith("PCB_DIM")
|
|
and hasattr(pcbnew, "VECTOR_SHAPEPTR")):
|
|
result.append(self.parse_dimension(d))
|
|
if hasattr(d, "Text"):
|
|
s = self.parse_text(d.Text())
|
|
else:
|
|
s = self.parse_text(d)
|
|
else:
|
|
self.logger.info("Unsupported drawing class %s, skipping",
|
|
d.GetClass())
|
|
if s:
|
|
result.append(s)
|
|
return result
|
|
|
|
def parse_edges(self, pcb):
|
|
edges = []
|
|
drawings = list(pcb.GetDrawings())
|
|
bbox = None
|
|
for f in self.footprints:
|
|
for g in f.GraphicalItems():
|
|
drawings.append(g)
|
|
for d in drawings:
|
|
if d.GetLayer() == pcbnew.Edge_Cuts:
|
|
for parsed_drawing in self.parse_drawing(d):
|
|
edges.append(parsed_drawing)
|
|
if bbox is None:
|
|
bbox = d.GetBoundingBox()
|
|
else:
|
|
bbox.Merge(d.GetBoundingBox())
|
|
if bbox:
|
|
bbox.Normalize()
|
|
return edges, bbox
|
|
|
|
def parse_drawings_on_layers(self, drawings, f_layer, b_layer):
|
|
front = []
|
|
back = []
|
|
|
|
for d in drawings:
|
|
if d[1].GetLayer() not in [f_layer, b_layer]:
|
|
continue
|
|
for drawing in self.parse_drawing(d[1]):
|
|
if d[0] in ["ref", "val"]:
|
|
drawing[d[0]] = 1
|
|
if d[1].GetLayer() == f_layer:
|
|
front.append(drawing)
|
|
else:
|
|
back.append(drawing)
|
|
|
|
return {
|
|
"F": front,
|
|
"B": back
|
|
}
|
|
|
|
def get_all_drawings(self):
|
|
drawings = [(d.GetClass(), d) for d in list(self.board.GetDrawings())]
|
|
for f in self.footprints:
|
|
drawings.append(("ref", f.Reference()))
|
|
drawings.append(("val", f.Value()))
|
|
for d in f.GraphicalItems():
|
|
drawings.append((d.GetClass(), d))
|
|
return drawings
|
|
|
|
def parse_pad(self, pad):
|
|
# type: (pcbnew.PAD) -> dict or None
|
|
layers_set = list(pad.GetLayerSet().Seq())
|
|
layers = []
|
|
if pcbnew.F_Cu in layers_set:
|
|
layers.append("F")
|
|
if pcbnew.B_Cu in layers_set:
|
|
layers.append("B")
|
|
pos = self.normalize(pad.GetPosition())
|
|
size = self.normalize(pad.GetSize())
|
|
angle = self.normalize_angle(pad.GetOrientation())
|
|
shape_lookup = {
|
|
pcbnew.PAD_SHAPE_RECT: "rect",
|
|
pcbnew.PAD_SHAPE_OVAL: "oval",
|
|
pcbnew.PAD_SHAPE_CIRCLE: "circle",
|
|
}
|
|
if hasattr(pcbnew, "PAD_SHAPE_TRAPEZOID"):
|
|
shape_lookup[pcbnew.PAD_SHAPE_TRAPEZOID] = "trapezoid"
|
|
if hasattr(pcbnew, "PAD_SHAPE_ROUNDRECT"):
|
|
shape_lookup[pcbnew.PAD_SHAPE_ROUNDRECT] = "roundrect"
|
|
if hasattr(pcbnew, "PAD_SHAPE_CUSTOM"):
|
|
shape_lookup[pcbnew.PAD_SHAPE_CUSTOM] = "custom"
|
|
if hasattr(pcbnew, "PAD_SHAPE_CHAMFERED_RECT"):
|
|
shape_lookup[pcbnew.PAD_SHAPE_CHAMFERED_RECT] = "chamfrect"
|
|
shape = shape_lookup.get(pad.GetShape(), "")
|
|
if shape == "":
|
|
self.logger.info("Unsupported pad shape %s, skipping.",
|
|
pad.GetShape())
|
|
return None
|
|
pad_dict = {
|
|
"layers": layers,
|
|
"pos": pos,
|
|
"size": size,
|
|
"angle": angle,
|
|
"shape": shape
|
|
}
|
|
if shape == "custom":
|
|
polygon_set = pad.GetCustomShapeAsPolygon()
|
|
if polygon_set.HasHoles():
|
|
self.logger.warn('Detected holes in custom pad polygons')
|
|
pad_dict["polygons"] = self.parse_poly_set(polygon_set)
|
|
if shape == "trapezoid":
|
|
# treat trapezoid as custom shape
|
|
pad_dict["shape"] = "custom"
|
|
delta = self.normalize(pad.GetDelta())
|
|
pad_dict["polygons"] = [[
|
|
[size[0] / 2 + delta[1] / 2, size[1] / 2 - delta[0] / 2],
|
|
[-size[0] / 2 - delta[1] / 2, size[1] / 2 + delta[0] / 2],
|
|
[-size[0] / 2 + delta[1] / 2, -size[1] / 2 - delta[0] / 2],
|
|
[size[0] / 2 - delta[1] / 2, -size[1] / 2 + delta[0] / 2],
|
|
]]
|
|
|
|
if shape in ["roundrect", "chamfrect"]:
|
|
pad_dict["radius"] = pad.GetRoundRectCornerRadius() * 1e-6
|
|
if shape == "chamfrect":
|
|
pad_dict["chamfpos"] = pad.GetChamferPositions()
|
|
pad_dict["chamfratio"] = pad.GetChamferRectRatio()
|
|
if hasattr(pcbnew, 'PAD_ATTRIB_PTH'):
|
|
through_hole_attributes = [pcbnew.PAD_ATTRIB_PTH,
|
|
pcbnew.PAD_ATTRIB_NPTH]
|
|
else:
|
|
through_hole_attributes = [pcbnew.PAD_ATTRIB_STANDARD,
|
|
pcbnew.PAD_ATTRIB_HOLE_NOT_PLATED]
|
|
if pad.GetAttribute() in through_hole_attributes:
|
|
pad_dict["type"] = "th"
|
|
pad_dict["drillshape"] = {
|
|
pcbnew.PAD_DRILL_SHAPE_CIRCLE: "circle",
|
|
pcbnew.PAD_DRILL_SHAPE_OBLONG: "oblong"
|
|
}.get(pad.GetDrillShape())
|
|
pad_dict["drillsize"] = self.normalize(pad.GetDrillSize())
|
|
else:
|
|
pad_dict["type"] = "smd"
|
|
if hasattr(pad, "GetOffset"):
|
|
pad_dict["offset"] = self.normalize(pad.GetOffset())
|
|
if self.config.include_nets:
|
|
pad_dict["net"] = pad.GetNetname()
|
|
|
|
return pad_dict
|
|
|
|
def parse_footprints(self):
|
|
# type: () -> list
|
|
footprints = []
|
|
for f in self.footprints: # type: pcbnew.FOOTPRINT
|
|
ref = f.GetReference()
|
|
|
|
# bounding box
|
|
if hasattr(pcbnew, 'MODULE'):
|
|
f_copy = pcbnew.MODULE(f)
|
|
else:
|
|
f_copy = pcbnew.FOOTPRINT(f)
|
|
try:
|
|
f_copy.SetOrientation(0)
|
|
except TypeError:
|
|
f_copy.SetOrientation(
|
|
pcbnew.EDA_ANGLE(0, pcbnew.TENTHS_OF_A_DEGREE_T))
|
|
pos = f_copy.GetPosition()
|
|
pos.x = pos.y = 0
|
|
f_copy.SetPosition(pos)
|
|
if hasattr(f_copy, 'GetFootprintRect'):
|
|
footprint_rect = f_copy.GetFootprintRect()
|
|
else:
|
|
footprint_rect = f_copy.GetBoundingBox(False, False)
|
|
bbox = {
|
|
"pos": self.normalize(f.GetPosition()),
|
|
"relpos": self.normalize(footprint_rect.GetPosition()),
|
|
"size": self.normalize(footprint_rect.GetSize()),
|
|
"angle": self.normalize_angle(f.GetOrientation()),
|
|
}
|
|
|
|
# graphical drawings
|
|
drawings = []
|
|
for d in f.GraphicalItems():
|
|
# we only care about copper ones, silkscreen is taken care of
|
|
if d.GetLayer() not in [pcbnew.F_Cu, pcbnew.B_Cu]:
|
|
continue
|
|
for drawing in self.parse_drawing(d):
|
|
drawings.append({
|
|
"layer": "F" if d.GetLayer() == pcbnew.F_Cu else "B",
|
|
"drawing": drawing,
|
|
})
|
|
|
|
# footprint pads
|
|
pads = []
|
|
for p in f.Pads():
|
|
pad_dict = self.parse_pad(p)
|
|
if pad_dict is not None:
|
|
pads.append((p.GetPadName(), pad_dict))
|
|
|
|
if pads:
|
|
# Try to guess first pin name.
|
|
pads = sorted(pads, key=lambda el: el[0])
|
|
pin1_pads = [p for p in pads if p[0] in
|
|
['1', 'A', 'A1', 'P1', 'PAD1']]
|
|
if pin1_pads:
|
|
pin1_pad_name = pin1_pads[0][0]
|
|
else:
|
|
# No pads have common first pin name,
|
|
# pick lexicographically smallest.
|
|
pin1_pad_name = pads[0][0]
|
|
for pad_name, pad_dict in pads:
|
|
if pad_name == pin1_pad_name:
|
|
pad_dict['pin1'] = 1
|
|
|
|
pads = [p[1] for p in pads]
|
|
|
|
# add footprint
|
|
footprints.append({
|
|
"ref": ref,
|
|
"bbox": bbox,
|
|
"pads": pads,
|
|
"drawings": drawings,
|
|
"layer": {
|
|
pcbnew.F_Cu: "F",
|
|
pcbnew.B_Cu: "B"
|
|
}.get(f.GetLayer())
|
|
})
|
|
|
|
return footprints
|
|
|
|
def parse_tracks(self, tracks):
|
|
tent_vias = True
|
|
if hasattr(self.board, "GetTentVias"):
|
|
tent_vias = self.board.GetTentVias()
|
|
result = {pcbnew.F_Cu: [], pcbnew.B_Cu: []}
|
|
for track in tracks:
|
|
if track.GetClass() in ["VIA", "PCB_VIA"]:
|
|
track_dict = {
|
|
"start": self.normalize(track.GetStart()),
|
|
"end": self.normalize(track.GetEnd()),
|
|
"width": track.GetWidth() * 1e-6,
|
|
"net": track.GetNetname(),
|
|
}
|
|
if not tent_vias:
|
|
track_dict["drillsize"] = track.GetDrillValue() * 1e-6
|
|
for layer in [pcbnew.F_Cu, pcbnew.B_Cu]:
|
|
if track.IsOnLayer(layer):
|
|
result[layer].append(track_dict)
|
|
else:
|
|
if track.GetLayer() in [pcbnew.F_Cu, pcbnew.B_Cu]:
|
|
if track.GetClass() in ["ARC", "PCB_ARC"]:
|
|
a1, a2 = self.get_arc_angles(track)
|
|
track_dict = {
|
|
"center": self.normalize(track.GetCenter()),
|
|
"startangle": a1,
|
|
"endangle": a2,
|
|
"radius": track.GetRadius() * 1e-6,
|
|
"width": track.GetWidth() * 1e-6,
|
|
}
|
|
else:
|
|
track_dict = {
|
|
"start": self.normalize(track.GetStart()),
|
|
"end": self.normalize(track.GetEnd()),
|
|
"width": track.GetWidth() * 1e-6,
|
|
}
|
|
if self.config.include_nets:
|
|
track_dict["net"] = track.GetNetname()
|
|
result[track.GetLayer()].append(track_dict)
|
|
|
|
return {
|
|
'F': result.get(pcbnew.F_Cu),
|
|
'B': result.get(pcbnew.B_Cu)
|
|
}
|
|
|
|
def parse_zones(self, zones):
|
|
result = {pcbnew.F_Cu: [], pcbnew.B_Cu: []}
|
|
for zone in zones: # type: pcbnew.ZONE
|
|
if (not zone.IsFilled() or
|
|
hasattr(zone, 'GetIsKeepout') and zone.GetIsKeepout() or
|
|
hasattr(zone, 'GetIsRuleArea') and zone.GetIsRuleArea()):
|
|
continue
|
|
layers = [layer for layer in list(zone.GetLayerSet().Seq())
|
|
if layer in [pcbnew.F_Cu, pcbnew.B_Cu]]
|
|
for layer in layers:
|
|
try:
|
|
# kicad 5.1 and earlier
|
|
poly_set = zone.GetFilledPolysList()
|
|
except TypeError:
|
|
poly_set = zone.GetFilledPolysList(layer)
|
|
width = zone.GetMinThickness() * 1e-6
|
|
if (hasattr(zone, 'GetFilledPolysUseThickness') and
|
|
not zone.GetFilledPolysUseThickness()):
|
|
width = 0
|
|
zone_dict = {
|
|
"polygons": self.parse_poly_set(poly_set),
|
|
"width": width,
|
|
}
|
|
if self.config.include_nets:
|
|
zone_dict["net"] = zone.GetNetname()
|
|
result[layer].append(zone_dict)
|
|
|
|
return {
|
|
'F': result.get(pcbnew.F_Cu),
|
|
'B': result.get(pcbnew.B_Cu)
|
|
}
|
|
|
|
@staticmethod
|
|
def parse_netlist(net_info):
|
|
# type: (pcbnew.NETINFO_LIST) -> list
|
|
nets = net_info.NetsByName().asdict().keys()
|
|
nets = sorted([str(s) for s in nets])
|
|
return nets
|
|
|
|
@staticmethod
|
|
def footprint_to_component(footprint, extra_fields):
|
|
try:
|
|
footprint_name = str(footprint.GetFPID().GetFootprintName())
|
|
except AttributeError:
|
|
footprint_name = str(footprint.GetFPID().GetLibItemName())
|
|
|
|
attr = 'Normal'
|
|
if hasattr(pcbnew, 'FP_EXCLUDE_FROM_BOM'):
|
|
if footprint.GetAttributes() & pcbnew.FP_EXCLUDE_FROM_BOM:
|
|
attr = 'Virtual'
|
|
elif hasattr(pcbnew, 'MOD_VIRTUAL'):
|
|
if footprint.GetAttributes() == pcbnew.MOD_VIRTUAL:
|
|
attr = 'Virtual'
|
|
layer = {
|
|
pcbnew.F_Cu: 'F',
|
|
pcbnew.B_Cu: 'B',
|
|
}.get(footprint.GetLayer())
|
|
|
|
return Component(footprint.GetReference(),
|
|
footprint.GetValue(),
|
|
footprint_name,
|
|
layer,
|
|
attr,
|
|
extra_fields)
|
|
|
|
def parse(self):
|
|
from ..errors import ParsingException
|
|
|
|
# Get extra field data from netlist
|
|
field_set = set(self.config.show_fields)
|
|
field_set.discard("Value")
|
|
field_set.discard("Footprint")
|
|
need_extra_fields = (field_set or
|
|
self.config.board_variant_whitelist or
|
|
self.config.board_variant_blacklist or
|
|
self.config.dnp_field)
|
|
|
|
if not self.config.extra_data_file and need_extra_fields:
|
|
self.logger.warn('Ignoring extra fields related config parameters '
|
|
'since no netlist/xml file was specified.')
|
|
need_extra_fields = False
|
|
|
|
extra_field_data = None
|
|
if (self.config.extra_data_file and
|
|
os.path.isfile(self.config.extra_data_file)):
|
|
extra_field_data = self.parse_extra_data(
|
|
self.config.extra_data_file, self.config.normalize_field_case)
|
|
|
|
if extra_field_data is None and need_extra_fields:
|
|
raise ParsingException(
|
|
'Failed parsing %s' % self.config.extra_data_file)
|
|
|
|
title_block = self.board.GetTitleBlock()
|
|
title = title_block.GetTitle()
|
|
revision = title_block.GetRevision()
|
|
company = title_block.GetCompany()
|
|
file_date = title_block.GetDate()
|
|
if (hasattr(self.board, "GetProject") and
|
|
hasattr(pcbnew, "ExpandTextVars")):
|
|
project = self.board.GetProject()
|
|
title = pcbnew.ExpandTextVars(title, project)
|
|
revision = pcbnew.ExpandTextVars(revision, project)
|
|
company = pcbnew.ExpandTextVars(company, project)
|
|
file_date = pcbnew.ExpandTextVars(file_date, project)
|
|
|
|
if not file_date:
|
|
file_mtime = os.path.getmtime(self.file_name)
|
|
file_date = datetime.fromtimestamp(file_mtime).strftime(
|
|
'%Y-%m-%d %H:%M:%S')
|
|
pcb_file_name = os.path.basename(self.file_name)
|
|
if not title:
|
|
# remove .kicad_pcb extension
|
|
title = os.path.splitext(pcb_file_name)[0]
|
|
edges, bbox = self.parse_edges(self.board)
|
|
if bbox is None:
|
|
self.logger.error('Please draw pcb outline on the edges '
|
|
'layer on sheet or any footprint before '
|
|
'generating BOM.')
|
|
return None, None
|
|
bbox = {
|
|
"minx": bbox.GetPosition().x * 1e-6,
|
|
"miny": bbox.GetPosition().y * 1e-6,
|
|
"maxx": bbox.GetRight() * 1e-6,
|
|
"maxy": bbox.GetBottom() * 1e-6,
|
|
}
|
|
|
|
drawings = self.get_all_drawings()
|
|
|
|
pcbdata = {
|
|
"edges_bbox": bbox,
|
|
"edges": edges,
|
|
"drawings": {
|
|
"silkscreen": self.parse_drawings_on_layers(
|
|
drawings, pcbnew.F_SilkS, pcbnew.B_SilkS),
|
|
"fabrication": self.parse_drawings_on_layers(
|
|
drawings, pcbnew.F_Fab, pcbnew.B_Fab),
|
|
},
|
|
"footprints": self.parse_footprints(),
|
|
"metadata": {
|
|
"title": title,
|
|
"revision": revision,
|
|
"company": company,
|
|
"date": file_date,
|
|
},
|
|
"bom": {},
|
|
"font_data": self.font_parser.get_parsed_font()
|
|
}
|
|
if self.config.include_tracks:
|
|
pcbdata["tracks"] = self.parse_tracks(self.board.GetTracks())
|
|
if hasattr(self.board, "Zones"):
|
|
pcbdata["zones"] = self.parse_zones(self.board.Zones())
|
|
else:
|
|
self.logger.info("Zones not supported for KiCad 4, skipping")
|
|
pcbdata["zones"] = {'F': [], 'B': []}
|
|
if self.config.include_nets and hasattr(self.board, "GetNetInfo"):
|
|
pcbdata["nets"] = self.parse_netlist(self.board.GetNetInfo())
|
|
|
|
if extra_field_data and need_extra_fields:
|
|
extra_fields = extra_field_data.fields_by_index
|
|
if extra_fields:
|
|
extra_fields = extra_fields.values()
|
|
|
|
if extra_fields is None:
|
|
extra_fields = []
|
|
field_map = extra_field_data.fields_by_ref
|
|
warning_shown = False
|
|
|
|
for f in self.footprints:
|
|
extra_fields.append(field_map.get(f.GetReference(), {}))
|
|
if f.GetReference() not in field_map:
|
|
# Some components are on pcb but not in schematic data.
|
|
# Show a warning about outdated extra data file.
|
|
self.logger.warn(
|
|
'Component %s is missing from schematic data.'
|
|
% f.GetReference())
|
|
warning_shown = True
|
|
|
|
if warning_shown:
|
|
self.logger.warn('Netlist/xml file is likely out of date.')
|
|
else:
|
|
extra_fields = [{}] * len(self.footprints)
|
|
|
|
components = [self.footprint_to_component(f, e)
|
|
for (f, e) in zip(self.footprints, extra_fields)]
|
|
|
|
return pcbdata, components
|
|
|
|
|
|
class InteractiveHtmlBomPlugin(pcbnew.ActionPlugin, object):
|
|
|
|
def __init__(self):
|
|
super(InteractiveHtmlBomPlugin, self).__init__()
|
|
self.name = "Generate Interactive HTML BOM"
|
|
self.category = "Read PCB"
|
|
self.pcbnew_icon_support = hasattr(self, "show_toolbar_button")
|
|
self.show_toolbar_button = True
|
|
icon_dir = os.path.dirname(os.path.dirname(__file__))
|
|
self.icon_file_name = os.path.join(icon_dir, 'icon.png')
|
|
self.description = "Generate interactive HTML page with BOM " \
|
|
"table and pcb drawing."
|
|
|
|
def defaults(self):
|
|
pass
|
|
|
|
def Run(self):
|
|
from ..version import version
|
|
from ..errors import ParsingException
|
|
|
|
logger = ibom.Logger()
|
|
board = pcbnew.GetBoard()
|
|
pcb_file_name = board.GetFileName()
|
|
|
|
if not pcb_file_name:
|
|
logger.error('Please save the board file before generating BOM.')
|
|
return
|
|
|
|
config = Config(version, os.path.dirname(pcb_file_name))
|
|
parser = PcbnewParser(pcb_file_name, config, logger, board)
|
|
|
|
try:
|
|
ibom.run_with_dialog(parser, config, logger)
|
|
except ParsingException as e:
|
|
logger.error(str(e))
|