def extract_kicad_library(kicad_library, edif_library):
""" Extracts all components, entities, from EDIF library """
# Always check for the library name as a parameter of
# the rename tag, otherwise use the parameter of the
# library tag
rename = edif_library.get_object("rename")
if rename != None:
library_name = rename.get_param(0)
else:
library_name = edif_library.get_param(0)
print "new library : ", library_name
cells = search_edif_objects(edif_library, "cell")
for edif_cell in cells:
view_list = search_edif_objects(edif_cell, "view")
if len(view_list) > 1:
cell_name_as_alias = extract_edif_str_param(edif_cell, 0)
print "multiview component: " + cell_name_as_alias[0] \
+ " creates new ones"
for view in view_list:
library_component = \
extract_edif_library_view(view,
cell_name_as_alias,
view_list.index(view))
kicad_library.add_component(library_component)
else:
library_component = extract_kicad_component_library(edif_cell)
kicad_library.add_component(library_component)
return kicad_library
def parse_schematic(parent_edif_object, filename,
project_name="TestTemplate"):
""" Extract a schematic page from EDIF """
schematic = KicadSchematic(filename, project_name)
edif_instances = search_edif_objects(parent_edif_object, "instance")
edif_nets = search_edif_objects(parent_edif_object, "net")
edif_ports = search_edif_objects(parent_edif_object, "portImplementation")
edif_annotations = search_edif_objects(parent_edif_object, "annotate")
edif_figures = search_edif_objects(parent_edif_object, "figure")
kicad_components = []
#kicad_noconnections = []
for instance in edif_instances:
kicad_append(kicad_components, extract_kicad_component(instance))
kicad_wires_list = []
kicad_net_aliases_list = []
kicad_junctions_list = []
for edif_net in edif_nets:
kicad_append(kicad_wires_list, extract_kicad_wires(edif_net))
kicad_append(kicad_net_aliases_list,
extract_kicad_net_aliases(edif_net))
kicad_append(kicad_junctions_list, extract_kicad_junctions(edif_net))
kicad_ports = []
for edif_port in edif_ports:
kicad_append(kicad_ports, extract_kicad_port(edif_port))
kicad_text_notes = []
for edif_annotation in edif_annotations:
kicad_append(kicad_text_notes,
extract_kicad_text_note(edif_annotation))
kicad_wire_notes_lines = []
for edif_figure in edif_figures:
kicad_append(kicad_wire_notes_lines,
extract_kicad_wire_notes_lines(edif_figure))
schematic.add_kicad_object(kicad_components)
#schematic.add_kicad_object( kicad_noconnections )
schematic.add_kicad_object(kicad_ports)
schematic.add_kicad_object(kicad_wires_list)
schematic.add_kicad_object(kicad_net_aliases_list)
schematic.add_kicad_object(kicad_junctions_list)
schematic.add_kicad_object(kicad_text_notes)
schematic.add_kicad_object(kicad_wire_notes_lines)
schematic.save()
return schematic
def extract_pin_parameters(port_impl_p_name, port_list):
""" Extract EDIF component pin parameters (text) """
pin_name = None
pin_type = None
pin_number = None
for port in port_list:
if extract_edif_str_param(port, 0)[0] == port_impl_p_name:
#print port_impl_p_name, "found"
properties = search_edif_objects(port, "property")
for prop in properties:
p1_name = remove_quote(extract_edif_str_param(prop, 0)[1])
string = \
remove_quote(prop.get_object("string").get_param(0))
#print p1_name, ":", string
if p1_name == "Name":
pin_name = string
elif p1_name == "Type":
pin_type = string
elif p1_name == "PackagePortNumbers":
pin_number = string
return [pin_name, pin_type, pin_number]
def get_edif_origin(parent_edif_object, output_path=".", \
project_name="test_project"):
""" extracts the originating tool name from the EDIF """
import_data_origin = "unknown"
import_data_version = "unknown"
status_list = search_edif_objects(parent_edif_object, "status")
for status_item in status_list:
if status_item != None:
#written_list = search_edif_objects(status, "written")
#for written_item in written_list:
#if written_item!=None:
written = status_item.get_object("written")
if written != None:
dataorigin = written.get_object("dataOrigin")
if dataorigin != None:
import_data_origin = dataorigin.get_param(0)
if import_data_origin != '""':
version = dataorigin.get_object("version")
if version != None:
import_data_version = version.get_param(0)
else:
import_data_version = "missing"
return {'origin':import_data_origin, 'version':import_data_version}
def extract_offset_path(library_component, path_list, offset_x, offset_y):
""" Extract EDIF path points with offset x, y coordinates """
for path in path_list:
point_list = search_edif_objects(path, "pointList")
extract_offset_point_list(library_component, point_list, offset_x,
offset_y)
return
def extract_offset_arc_point_list(library_component, point_list, offset_x,
offset_y):
""" Extract EDIF arc points with offset x, y to KiCad arc """
for ptl in point_list:
arc = KicadArc()
arc.set_offset(offset_x, offset_y)
points = search_edif_objects(ptl, "pt")
for pointxy in points:
xpos, ypos = convert_kicad_coor(extract_edif_pt(pointxy))
arc.add_point(xpos, ypos)
library_component.add_draw(arc)
return
def extract_offset_point_list(library_component, point_list, offset_x,
offset_y):
""" Extract EDIF point list (segments) with offset x, y """
for ptl in point_list:
poly = KicadPoly()
poly.set_offset(offset_x, offset_y)
points = search_edif_objects(ptl, "pt")
for pointxy in points:
xpos, ypos = convert_kicad_coor(extract_edif_pt(pointxy))
poly.add_segment(xpos, ypos)
library_component.add_draw(poly)
return
def parse_libraries(parent_edif_object, output_path=".",
project_name="TestTemplate"):
""" extract all libraries and components from the EDIF """
libraries = search_edif_objects(parent_edif_object, "library")
kicad_library = KicadLibrary(output_path+"/"+project_name+"-cache")
if libraries != None:
for edif_library in libraries:
extract_kicad_library(kicad_library, edif_library)
kicad_library.save()
return kicad_library
def extract_kicad_junctions(edif_net):
""" Extracts a junction from EDIF and creates a KiCad junction """
junctions = []
instances = search_edif_objects(edif_net, "instance")
for instance in instances:
if instance != None:
#ident = instance.get_param(0)
edif_pt = instance.get_object("transform.origin.pt")
if edif_pt != None:
xpos, ypos = convert_kicad_coor(extract_edif_pt(edif_pt))
junction = KicadJunction(xpos, ypos)
junctions.append(junction)
if len(junctions) == 0:
return None
else:
return junctions
def extract_offset_drawing(library_component, figure_list, offset_x, offset_y):
""" Extract EDIF drawing with offset x, y to KiCad drawing """
for figure in figure_list:
figure_type = extract_edif_str_param(figure, 0)
if figure_type != None:
path_list = search_edif_objects(figure, "path")
extract_offset_path(library_component, path_list, offset_x,
offset_y)
point_list = figure.get_object("polygon.pointList")
if point_list != None:
extract_offset_point_list(library_component, [point_list],
offset_x, offset_y)
arc_point_list = figure.get_object("openShape.curve.arc")
if arc_point_list != None:
extract_offset_arc_point_list(library_component, [arc_point_list],
offset_x, offset_y)
rectangle = figure.get_object("rectangle")
if rectangle != None:
xstart, ystart = \
convert_kicad_coor(extract_edif_pt(rectangle.get_param(0)))
xend, yend = \
convert_kicad_coor(extract_edif_pt(rectangle.get_param(1)))
rectangle = KicadRectangle(xstart, ystart, xend, yend)
rectangle.set_offset(offset_x, offset_y)
library_component.add_draw(rectangle)
circle = figure.get_object("circle")
if circle != None:
xstart, ystart = \
convert_kicad_coor(extract_edif_pt(circle.get_param(0)))
xend, yend = \
convert_kicad_coor(extract_edif_pt(circle.get_param(1)))
circle = KicadCircle(xstart, ystart, xend, yend)
circle.set_offset(offset_x, offset_y)
library_component.add_draw(circle)
return
def extract_kicad_net_aliases(edif_net):
""" Extracts a net alias text from EDIF and creates a KiCad net alias """
net_aliases = []
net_name = extract_edif_str_param(edif_net, 0)
if net_name != None:
if type(net_name[0]) != unicode:
display_list = search_edif_objects(net_name[0], "display")
for display in display_list:
edif_pt = display.get_object("origin.pt")
if edif_pt != None:
xpos, ypos = convert_kicad_coor(extract_edif_pt(edif_pt))
#print net_name[1], xpos, y
net_alias = \
KicadNetAlias(xpos, ypos,
normalize_edif_string(net_name[1]))
net_aliases.append(net_alias)
if len(net_aliases) == 0:
return None
else:
return net_aliases
def find_edif_points_maxmin(point_list, maxmin_xy):
""" Finds the max and min x, y in an EDIF point list """
max_x = maxmin_xy[0][0]
max_y = maxmin_xy[0][1]
min_x = maxmin_xy[1][0]
min_y = maxmin_xy[1][1]
#print "maxmin: max_xy " + str([max_x, max_y]) \
# + ", min_xy " + str([min_x, min_y])
for point in point_list:
points = search_edif_objects(point, "pt")
for pointxy in points:
xpos, ypos = convert_kicad_coor(extract_edif_pt(pointxy))
if xpos > max_x:
max_x = xpos
if ypos > max_y:
max_y = ypos
if xpos < min_x:
min_x = xpos
if ypos < min_y:
min_y = ypos
return [max_x, max_y], [min_x, min_y]
def extract_kicad_wires(edif_net):
""" Extracts a wire from EDIF and creates a KiCad wire """
wires = []
xnext, ynext = [0, 0]
figures = search_edif_objects(edif_net, "figure")
for figure in figures:
if figure != None:
if figure.get_param(0) == "WIRE":
pts = figure.get_object("path.pointList")
for i in range(0, pts.get_nb_param()):
edif_pt = pts.get_param(i)
xpos, ypos = convert_kicad_coor(extract_edif_pt(edif_pt))
if i > 0:
wire = KicadWire(xnext, ynext, xpos, ypos)
wires.append(wire)
xnext, ynext = [xpos, ypos]
if len(wires) == 0:
return None
else:
return wires
def extract_kicad_wire_notes_lines(edif_figure):
""" Parse EDIF figure DASHED_LINE polygon
from schematic to KiCad schematic
"""
wire_notes_lines = []
xpos, ypos = [0, 0]
startx, starty = [0, 0]
fromx, fromy = [0, 0]
figure_group_override = edif_figure.get_object("figureGroupOverride")
if figure_group_override != None:
figure_style = figure_group_override.get_param(0)
#print "figure style = " + str(figure_style)
if figure_style == "DASHED_LINE":
point_list = edif_figure.get_object("polygon.pointList")
edif_pts = search_edif_objects(point_list, "pt")
points = 1
for edif_pt in edif_pts:
xpos, ypos = convert_kicad_coor(extract_edif_pt(edif_pt))
if points == 1:
fromx, fromy = [xpos, ypos]
startx, starty = [xpos, ypos]
else:
line = KicadWireNotesLine(fromx, fromy, xpos, ypos)
wire_notes_lines.append(line)
fromx, fromy = [xpos, ypos]
points += 1
if points >= 2:
line = KicadWireNotesLine(fromx, fromy, startx, starty)
wire_notes_lines.append(line)
if len(wire_notes_lines) == 0:
return None
else:
return wire_notes_lines
def extract_kicad_component(instance):
""" Extracts a component from EDIF and creates a KiCad component """
f_data = []
view_ref = instance.get_object("viewRef")
#cell_ref = view_ref.get_object("cellRef")
libname = "" + view_ref.get_param(0)
#libname = "IMPORT_"+cellRef.get_param(0)
hvjustify = text_justify("CENTERCENTER", "R0", "R0")
refdes_orientation = "H"
comp_orientation = "H"
xpos = 0
ypos = 0
# F 0
string_display = instance.get_object("designator.stringDisplay")
if string_display == None:
return None
ref_design = string_display.get_param(0)
kicad_component = KicadSchematicComponent(libname, ref_design)
# component orientation
instance_orientation = instance.get_object("transform.orientation")
if instance_orientation != None:
comp_orientation = remove_quote(instance_orientation.get_param(0))
else:
comp_orientation = "R0"
kicad_component.set_orientation(comp_orientation)
display_orientation = string_display.get_object("display.orientation")
if display_orientation != None:
refdes_orientation = remove_quote(display_orientation.get_param(0))
else:
refdes_orientation = "R0"
refdes_orientation = convert_edif_orientation_to_hv(
refdes_orientation, comp_orientation)
# component position - the reference point
edif_pt = instance.get_object("transform.origin.pt")
if edif_pt != None:
component_x, component_y = convert_kicad_coor(extract_edif_pt(edif_pt))
kicad_component.set_position(component_x, component_y)
component_xy = [component_x, component_y]
# Position designator for Kicad coordinates
# - designator X is relative to component X for rotation and mirroring
# - designator ypos is flipped relative to
# component x-axis line of symmetry
# - visible properties text is offset from component
# relative to designator [xpos, ypos]
#prop_xy = component_xy
edif_pt = string_display.get_object("display.origin.pt")
if edif_pt != None:
xpos, ypos = convert_kicad_local_coor(extract_edif_pt(edif_pt),
component_xy, comp_orientation)
#prop_xy = convert_kicad_local_coor(extract_edif_pt(edif_pt),
# component_xy,
# comp_orientation)
display_orientation = string_display.get_object("display.orientation")
if display_orientation != None:
text_orientation = remove_quote(display_orientation.get_param(0))
else:
text_orientation = "R0"
display_justify = string_display.get_object("display.justify")
if display_justify != None:
hvjustify = text_justify(display_justify.get_param(0),
text_orientation, comp_orientation)
f_data.append({
'ref': ref_design,
'posx': xpos,
'posy': ypos,
'orient': refdes_orientation,
'hjust': hvjustify[0],
'props': hvjustify[1] + "NN"
})
# F 1 "Value"
properties = search_edif_objects(instance, "property")
for prop in properties:
if extract_edif_str_param(prop, 0)[0] == "VALUE":
f_prop = build_kicad_field(prop, component_xy, comp_orientation)
if f_prop != None:
f_data.append(f_prop)
# F 2 "Footprint"
for prop in properties:
if extract_edif_str_param(prop, 0)[0] == "PCB_FOOTPRINT":
f_prop = build_kicad_field(prop, component_xy, comp_orientation)
#print str(f_prop)
if f_prop != None:
f_data.append(f_prop)
# F 3 "Data Link"
f_data.append({
'ref': '""',
'posx': component_x,
'posy': component_y,
'attributs': '0001'
})
# F 4 and up
for prop in properties:
if extract_edif_str_param(prop, 0)[0] != "VALUE":
# f_prop = build_kicad_field(prop, prop_xy, comp_orientation)
f_prop = build_kicad_field(prop, component_xy, comp_orientation)
if f_prop != None:
f_data.append(f_prop)
#print value + " " + f1_data['attributs']
#*******
for field in f_data:
kicad_component.add_field(field)
return kicad_component
def _extract_component_view(view, library_component):
""" Extracts an EDIF component or drawing entity to KiCad """
view_name = extract_edif_str_param(view, 0)
ref = "?"
xpos = int(0)
ypos = int(0)
value_x = int(0)
value_y = int(0)
visible = "V"
orientation = "H"
hvjustify = text_justify("CENTERCENTER", "R0", "R0")
interface = view.get_object("interface")
if interface != None:
symbol = interface.get_object("symbol")
if symbol != None:
prop_list = search_edif_objects(symbol, "property")
if prop_list != None:
for prop in prop_list:
prop_type = extract_edif_str_param(prop, 0)[0]
if prop_type == "VALUE":
value_x, value_y = get_edif_string_anchor(prop)
elif prop_type == "PIN_NAMES_VISIBLE":
string = prop.get_object("string")
if string != None:
pin_names_visible = \
remove_quote(extract_edif_str_param(string, 0)[1])
if pin_names_visible == "False":
library_component.set_pin_names_visible(False)
elif prop_type == "PIN_NUMBERS_VISIBLE":
string = prop.get_object("string")
if string != None:
pin_numbers_visible = \
remove_quote(extract_edif_str_param(string, 0)[1])
if pin_numbers_visible == "False":
library_component.set_pin_numbers_visible(
False)
figure_list = search_edif_objects(symbol, "figure")
extract_drawing(library_component, figure_list)
port_impl_list = search_edif_objects(symbol, "portImplementation")
port_list = search_edif_objects(interface, "port")
extract_connections(library_component, port_impl_list, port_list)
designator = interface.get_object("designator")
if designator != None:
#print "designator = "+extract_str_param(designator, 0)[1]
ref = extract_edif_str_param(designator, 0)[1]
ref = remove_quote(ref)
if ref.endswith('?'):
ref = ref[:-1]
#pointxy = get_edif_string_anchor(designator)
#print "pointxy = " + str(pointxy)
string_display = designator.get_object("stringDisplay")
if string_display != None:
print "Info: found extra information in reference designator:"
pointxy = string_display.get_object("display.origin.pt")
if pointxy != None:
print " " + str(extract_edif_pt(pointxy))
# xpos, ypos = convert_kicad_coor(extract_edif_pt(pointxy))
# display_justify = string_display.get_object("display.justify")
# if display_justify != None:
# hvjustify = text_justify(display_justify.get_param(0),
# "R0")
# print "JUSTIFY with " + str(hvjustify)
else:
pointxy = \
interface.get_object("symbol.keywordDisplay.\
display.origin.pt" )
if pointxy != None:
xpos, ypos = convert_kicad_coor(extract_edif_pt(pointxy))
display_justify = \
interface.get_object("symbol.keywordDisplay.\
display.justify" )
if display_justify != None:
hvjustify = text_justify(display_justify.get_param(0),
"R0", "R0")
#print "JUSTIFY with " + str(hvjustify)
contents = view.get_object("contents")
if contents != None:
figure_list = search_edif_objects(contents, "figure")
figure = figure_list[0]
figure_group_override = figure.get_object("figureGroupOverride")
if figure_group_override != None:
figure_name = figure_group_override.get_param(0)
else:
figure_name = figure.get_param(0)
if figure_name == "POWEROBJECT":
power_symbol = extract_powerobject_symbol(library_component,
view_name[0],
figure_list)
if power_symbol['is_valid'] == True:
if power_symbol['is_ground'] == True:
#print "**** GND"
xpos = 0
ypos = power_symbol['min_y']
value_x = 0
value_y = power_symbol['min_y'] - 100
else:
#print "**** POWER"
xpos = 0
ypos = power_symbol['min_y']
value_x = 0
value_y = power_symbol['max_y'] + 100
visible = "V"
orientation = "V"
ref = "#PWR"
library_component.set_pin_names_visible(False)
library_component.set_pin_numbers_visible(False)
# pylint: disable=W0105
"""
#
# GND
#
DEF GND #PWR 0 0 Y Y 1 F P
F0 "#PWR" 0 -250 50 H I C CNN
F1 "GND" 0 -150 50 H V C CNN
F2 "" 0 0 50 H I C CNN
F3 "" 0 0 50 H I C CNN
DRAW
P 6 0 1 0 0 0 0 -50 50 -50 0 -100 -50 -50 0 -50 N
X GND 1 0 0 0 D 50 50 1 1 W N
ENDDRAW
ENDDEF
#
# +3V3
#
DEF +3V3 #PWR 0 0 Y Y 1 F P
F0 "#PWR" 0 -150 50 H I C CNN
F1 "+3V3" 0 140 50 H V C CNN
F2 "" 0 0 50 H I C CNN
F3 "" 0 0 50 H I C CNN
ALIAS +3.3V
DRAW
P 2 0 1 0 -30 50 0 100 N
P 2 0 1 0 0 0 0 100 N
P 2 0 1 0 0 100 30 50 N
X +3V3 1 0 0 0 U 50 50 1 1 W N
ENDDRAW
ENDDEF
"""
library_component.set_designator(ref)
#print "x = " + str(xpos) + ", ypos = " + str(ypos) + "; vx = " \
# + str(value_x) + ", vy = " + str(value_y) + ";"
library_component.add_field({
'id': 0,
'ref': add_quote(ref),
'posx': xpos,
'posy': ypos,
'visible': 'I',
'text_align': hvjustify[0],
'props': hvjustify[1] + "NN"
})
library_component.add_field({
'id': 1,
'ref': add_quote(view_name[0]),
'visible': visible,
'posx': value_x,
'posy': value_y
})
library_component.add_field({'id': 2, 'ref': '""', 'posx': 0, 'posy': 0})
library_component.add_field({'id': 3, 'ref': '""', 'posx': 0, 'posy': 0})
return library_component
def extract_powerobject_symbol(library_component, name, figure_list):
""" Extracts EDIF powerobject, a type of port """
is_ground = False
symbol_info = {
'is_valid': True,
'is_ground': False,
'min_x': 0,
'min_y': 0,
'max_x': 0,
'max_y': 0
}
max_x = -2**32
max_y = -2**32
min_x = 2**32
min_y = 2**32
x_offset = 0
y_offset = 0
figure = figure_list[0]
figure_group_override = figure.get_object("figureGroupOverride")
if figure_group_override != None:
figure_name = figure_group_override.get_param(0)
else:
figure_name = figure.get_param(0)
if figure_name == "POWEROBJECT":
ref = "#PWR"
max_xy = [max_x, max_y]
min_xy = [min_y, min_y]
for figure in figure_list:
path_list = search_edif_objects(figure, "path")
if len(path_list) != 0:
for path in path_list:
point_list = search_edif_objects(path, "pointList")
max_xy, min_xy = find_edif_points_maxmin(
point_list, [max_xy, min_xy])
circle = search_edif_objects(figure, "circle")
if len(circle) != 0:
print " found circle in POWEROBJECT"
max_xy, min_xy = find_edif_points_maxmin(
circle, [max_xy, min_xy])
rectangle = search_edif_objects(figure, "rectangle")
if len(rectangle) != 0:
print " found rect in POWEROBJECT"
max_xy, min_xy = find_edif_points_maxmin(
rectangle, [max_xy, min_xy])
#print "POWEROBJECT: max_xy " + str(max_xy) \
# + ", min_xy " + str(min_xy)
max_x = max_xy[0]
max_y = max_xy[1]
min_x = min_xy[0]
min_y = min_xy[1]
connection = KicadConnection("1", name)
x_offset = -(min_x + (max_x - min_x) / 2)
if name in set(['GND', 'DGND', 'AGND', 'EARTH', 'GND_POWER']):
y_offset = 0
connection.set_pin(0, 0, 0, -1)
is_ground = True
else:
y_offset = (max_y - min_y)
connection.set_pin(0, 0, 0, 1)
library_component.set_powerobject(True)
library_component.add_connection(connection)
extract_offset_drawing(library_component, figure_list, x_offset,
y_offset)
else:
symbol_info['is_valid'] = False
print "ERROR: could not extract power symbol"
return
#print "x_offset = " + str(x_offset) + ", y_offset = " + str(y_offset)
#print "(" + name + " figures captured for " + ref + ", " + str(max_x) \
# + ", " + str(max_y) + "; " + str(min_x) + ", " + str(min_y) + ")"
symbol_info['is_ground'] = is_ground
symbol_info['min_x'] = min_x
symbol_info['min_y'] = min_y
symbol_info['max_x'] = max_x
symbol_info['max_y'] = max_y
return symbol_info
if version != None:
if version[0] == '2' and version[1] == '0' and version[2] == '0':
print "Edif 2.0.0 checked ;)"
import_origin = get_edif_origin(edif_object)
print "Import origin: " \
+ str(import_origin['origin']) \
+ " version: " + str(import_origin['version'])
import_style = set_import_style(import_origin['origin'],
import_origin['version'])
parse_libraries(edif_object, output_path, project_name)
print "---------------------------------------------"
pages = search_edif_objects(edif_object, "page")
page_nb = 0
for page in pages:
page_nb += 1
page_names = extract_edif_str_param(page, 0)
#page_name = page_names[1].replace(' ', '_')
page_name = page_names[1].replace('\"', '')
#filename = output_path + page_name
#filename = output_path + project_name + " - " + page_name
filename = output_path + project_name
print filename
parse_schematic(page, filename, project_name)
sys.exit(0)
