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 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 extract_kicad_component_library(edif_cell):
""" Extracts a single EDIF cell (component) from a library """
cell_name = extract_edif_str_param(edif_cell, 0)
#cell_name = cell.get_param(0)
#print cell_name
view = edif_cell.get_object("view")
view_name = extract_edif_str_param(view, 0)
#print view_name[0], view_name[0]
library_component = KicadLibraryComponent(cell_name[0])
library_component.add_alias(view_name[0])
_extract_component_view(view, library_component)
return library_component
def extract_edif_library_view(view, cell_name, view_index):
""" Extract a single EDIF component view (convert drawing) """
view_name = extract_edif_str_param(view, 0)
library_component = KicadLibraryComponent(view_name[0])
library_component.add_alias(cell_name[0] + "_" \
+ chr(ord('A') + view_index))
_extract_component_view(view, library_component)
return library_component
def get_edif_string_anchor(prop):
""" Helper function: get x, y anchor for string """
xpos, ypos = [0, 0]
string = prop.get_object("string")
if string != None:
string_display = string.get_object("stringDisplay")
else:
string_display = prop.get_object("stringDisplay")
if string_display != None:
value = string_display.get_param(0)
pointxy = string_display.get_object("display.origin.pt")
if pointxy != None:
xpos, ypos = convert_kicad_coor(extract_edif_pt(pointxy))
else:
print "WARN: string with no point in EDIF as " \
+ str(extract_edif_str_param(string, 0)[0])
return [xpos, ypos]
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 _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
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)
def extract_kicad_port(edif_port):
""" Extracts a port from EDIF and creates a KiCad port """
# portImplementation, pI
port_is_labeled = False
hvjustify = text_justify("CENTERCENTER", "R0", "R0")
refdes_orientation = "H"
port_orientation = "H"
porttext_x, porttext_y = [0, 0]
# p2
instance = edif_port.get_object("instance")
p2_name = normalize_edif_string(extract_edif_str_param(instance, 0)[1])
#print "p2_name = " + str(p2_name)
view_ref = instance.get_object("viewRef")
name = view_ref.get_param(0)
# pylint: disable=W0105
"""
edif_pt = instance.get_object("transform.origin.pt")
if edif_pt != None:
component_x, component_y = extract_pt(edif_pt)
"""
port_orientation = instance.get_object("transform.orientation")
if port_orientation != None:
port_orientation = remove_quote(port_orientation.get_param(0))
else:
port_orientation = "R0"
edif_pt = edif_port.get_object("connectLocation.figure.dot.pt")
if edif_pt != None:
component_x, component_y = convert_kicad_coor(extract_edif_pt(edif_pt))
else:
return
#print "x, ypos = " + str([component_x, component_y])
port_instance = edif_port.get_param(0)
if type(port_instance) == unicode:
p_inst_type = None
p_inst_name = port_instance
#print "UNICODE: " + str(port_instance)
else:
instance = edif_port.get_object("instance")
if instance != None:
view_ref = instance.get_object("viewRef")
p_inst_type = port_instance.get_context()
if p_inst_type == "name":
# text module
p_inst_name = normalize_edif_string(port_instance.get_param(0))
#print "pI_name = " + str(p_inst_name)
display = port_instance.get_object("display")
if display != None:
p_inst_type = display.get_param(0)
designator_pt = display.get_object("origin.pt")
display_orientation = display.get_object("orientation")
if display_orientation != None:
text_orientation = \
remove_quote(display_orientation.get_param(0))
else:
text_orientation = "R0"
display_justify = display.get_object("justify")
if display_justify != None:
hvjustify = text_justify(display_justify.get_param(0),
text_orientation, port_orientation)
display_orientation = display.get_object("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,
port_orientation)
if designator_pt != None:
porttext_x, porttext_y = \
convert_kicad_local_coor(extract_edif_pt(designator_pt),
[component_x, component_y],
port_orientation)
port_is_labeled = True
#print "port " + str(p_inst_name) + " of " \
# + str(p_inst_type) + " at : " + str(porttext_x) \
# + ", " + str(porttext_y)
# TODO: test EDIF MODULETEXT and KicadTextPort class
if p_inst_type == "MODULETEXT":
text_port = KicadTextPort(p_inst_name, component_x, component_y)
name, rot = name.split("_")
name = name.replace("PORT", "")
if name == "BOTH":
port_type = "BiDi"
elif name == "LEFT":
port_type = "Output"
elif name == "RIGHT":
port_type = "Input"
else:
port_type = "UnSpc"
if rot == "L":
angle = 1
else:
angle = 0
def_rot = {
"R0": [0, 2],
"R90": [3, 1],
"R180": [2, 0],
"R270": [1, 3],
"MY": [2, 0],
"MYR90": [1, 3],
#"MYR180":[0, 2],
#"MYR270":[1, 3],
"MX": [0, 2],
"MXR90": [3, 1],
#"MXR180":[0, 2],
#"MXR270":[1, 3]
}
comb_angle = def_rot[port_orientation][angle]
#print name, rot, orientation, comb_angle
text_port.set_text(p2_name[1])
text_port.set_type(port_type)
text_port.set_rotation(comb_angle)
return text_port
if p_inst_type == "POWERTEXT" or \
(p_inst_type == None and p_inst_name in {'GND', 'GNDA', 'GNDD',
'GNDS', 'EARTH',
'GND_POWER'}):
ref = "\"#PWR?\""
else:
ref = "\"" + name + "\""
value = "\"" + p_inst_name + "\""
#x = component_x
#y = component_y
xpos, ypos = [porttext_x, porttext_y]
f0_data = {'ref': ref, 'posx': xpos, 'posy': ypos, 'attributs': '0001'}
if port_is_labeled == True:
f1_data = {
'ref': value,
'posx': porttext_x,
'posy': porttext_y,
'attributs': '0000',
'orient': refdes_orientation,
'hjust': hvjustify[0],
'props': hvjustify[1] + "NN"
}
else:
f1_data = {
'ref': value,
'posx': xpos,
'posy': ypos,
'attributs': '0001'
}
f2_data = {
'ref': '""',
'posx': component_x,
'posy': component_y,
'attributs': '0001'
}
f3_data = {
'ref': '""',
'posx': component_x,
'posy': component_y,
'attributs': '0001'
}
kicad_component = KicadSchematicComponent(name, ref)
kicad_component.set_position(component_x, component_y)
kicad_component.set_orientation(port_orientation)
kicad_component.add_field(f0_data)
kicad_component.add_field(f1_data)
kicad_component.add_field(f2_data)
kicad_component.add_field(f3_data)
return kicad_component
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 build_kicad_field(prop, ref_xy, symbol_orientation):
""" Builds a single KiCad schematic "F n" property field:
F field_number 'text' orientation posX posY size Flags
hjustify vjustify/italic/bold 'name'
These properties typically start at F 4, or the 5th
property of a component and onwards
Example:
F 4 "Infineon" H 2300 4500 50 0000 L TNN "Manufacturer"
F 5 "ESD108-B1-CSP0201" H 2300 4400 50 0000 L TNN
"Manufacturer Part Number"
F 6 "D DIODE BIDIRECTIONAL TVS" H 0 0 50 0001 C CNN "Source Package"
...
Returns:
A dictionary of "F" elements
"""
prop_attributs = int('0', 2)
orientation = "H"
hvjustify = text_justify("CENTERCENTER", "R0", symbol_orientation)
xpos = 0
ypos = 0
property_name = extract_edif_str_param(prop, 0)
#property_tag = str(property_name[0])
#print "name = " + str(property_name[1]) + "(" + property_tag + ")"
name = str(property_name[1])
string = prop.get_object("string")
if string != None:
#value = extract_edif_str_param(string, 0)
value = str(string.get_param(0))
#print "value = " + value
string_display = string.get_object("stringDisplay")
if string_display != None:
value = string_display.get_param(0)
#print "SCH: prop value = " + str(value)
display_orientation = \
string_display.get_object("display.orientation")
if display_orientation != None:
prop_orientation = \
remove_quote(display_orientation.get_param(0))
else:
prop_orientation = "R0"
orientation = convert_edif_orientation_to_hv(
prop_orientation, symbol_orientation)
edif_pt = string_display.get_object("display.origin.pt")
if edif_pt != None:
xpos, ypos = convert_kicad_local_coor(extract_edif_pt(edif_pt),
ref_xy,
symbol_orientation)
#print " field xy = " + str([xpos, ypos]) \
# + "orientation = " \
# + symbol_orientation
if value == '"N/A"':
prop_attributs = bin(prop_attributs | TEXT_NO_VISIBLE)
else:
prop_attributs = int('0', 2)
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, symbol_orientation)
figure_group_override = \
string_display.get_object("display.figureGroupOverride")
if figure_group_override != None:
visible_false = \
figure_group_override.get_object("visible.false")
if visible_false != None:
prop_attributs = bin(prop_attributs | TEXT_NO_VISIBLE)
#prop_attributs = int('1', 2)
else:
prop_attributs = bin(prop_attributs & ~TEXT_NO_VISIBLE)
#prop_attributs = int('0', 2)
else:
prop_attributs = bin(prop_attributs | TEXT_NO_VISIBLE)
#print "ref des coordinates assigned to prop value " \
# + str(value) + " of " + str(property_name[0])
#value = ""
f_data = {
'ref': value,
'posx': xpos,
'posy': ypos,
'attributs': eda_attribut_string(prop_attributs),
'orient': orientation,
'hjust': hvjustify[0],
'props': hvjustify[1] + "NN",
'name': name
}
return f_data
return None