def parse_symbol_attribute(self, symbol_attribute):
""" Extract attributes from a symbol. """
x = int(symbol_attribute.get('x'))
y = int(symbol_attribute.get('y'))
rotation = float(symbol_attribute.get('rotation'))
# Make SymbolAttribute
symbol_attr = SymbolAttribute(x, y, rotation)
# Add Annotations
for annotation in symbol_attribute.get('annotations'):
anno = self.parse_annotation(annotation)
symbol_attr.add_annotation(anno)
# Return SymbolAttribute to be added to it's ComponentInstance
return symbol_attr
def parse_component_instance(self, f):
""" Parse a component instance from a $Comp block """
# pylint: disable=R0914
# name & reference
prefix, name, reference = f.readline().split()
assert prefix == 'L'
# unit & convert
prefix, unit, convert, _ = f.readline().split(None, 3)
unit, convert = int(unit), int(convert)
assert prefix == 'U'
# position
prefix, compx, compy = f.readline().split()
assert prefix == 'P'
compx, compy = int(compx), int(compy)
line = f.readline()
rotation = 0
annotations = []
while line.strip() not in ("$EndComp", ''):
if line.startswith('F '):
parts = line.split('"', 2)
value = parts[1].decode('utf-8', errors='replace')
parts = parts[2].strip().split()
annotations.append(
Annotation(value,
make_length(int(parts[1]) - compx),
-make_length(int(parts[2]) - compy),
0 if parts[0] == 'H' else 1, 'true'))
elif line.startswith('\t'):
parts = line.strip().split()
if len(parts) == 4:
rotation = MATRIX2ROTATION.get(
tuple(int(i) for i in parts), 0)
line = f.readline()
inst = ComponentInstance(reference, name, convert - 1)
symbattr = SymbolAttribute(make_length(compx), -make_length(compy),
rotation)
for ann in annotations:
symbattr.add_annotation(ann)
inst.add_symbol_attribute(symbattr)
return inst
def parse_component(self, stream, params):
""" Creates a component instance according to the component *params*.
If the component is not known in the library, a the component
will be created according to its description in the embedded
environment ``[]`` or a symbol file. The component is added
to the library automatically if necessary.
An instance of this component will be created and added to
the design.
A GEDAError is raised when either the component file
is invalid or the referenced symbol file cannot be found
in the known directories.
Returns a tuple of Component and ComponentInstance objects.
"""
basename, dummy = os.path.splitext(params['basename'])
component_name = basename
if params['mirror']:
component_name += '_MIRRORED'
if component_name in self.design.components.components:
component = self.design.components.components[component_name]
## skipping embedded data might be required
self.skip_embedded_section(stream)
else:
##check if sym file is embedded or referenced
if basename.startswith('EMBEDDED'):
## embedded only has to be processed when NOT in symbol lookup
if basename not in self.known_symbols:
component = self.parse_component_data(stream, params)
else:
if basename not in self.known_symbols:
log.warn("referenced symbol file '%s' unknown" % basename)
## parse optional attached environment before continuing
self._parse_environment(stream)
return None, None
## requires parsing of referenced symbol file
f_in = open(self.known_symbols[basename], "rU")
self._check_version(f_in)
component = self.parse_component_data(f_in, params)
f_in.close()
self.design.add_component(component_name, component)
## get all attributes assigned to component instance
attributes = self._parse_environment(stream)
## refdes attribute is name of component (mandatory as of gEDA doc)
## examples if gaf repo have components without refdes, use part of
## basename
if attributes is not None:
instance = ComponentInstance(
attributes.get('_refdes', component.name),
component.name,
0
)
for key, value in attributes.items():
instance.add_attribute(key, value)
else:
instance = ComponentInstance(
component.name,
component.name,
0
)
## generate a component instance using attributes
self.design.add_component_instance(instance)
symbol = SymbolAttribute(
self.x_to_px(params['x']),
self.y_to_px(params['y']),
self.conv_angle(params['angle'])
)
instance.add_symbol_attribute(symbol)
## add annotation for special attributes
for idx, attribute_key in enumerate(['_refdes', 'device']):
if attribute_key in component.attributes \
or attribute_key in instance.attributes:
symbol.add_annotation(
Annotation(
'{{%s}}' % attribute_key,
0, 0+idx*10, 0.0, 'true'
)
)
return component, instance
def parse(self, filename, library_filename=None):
""" Parse a kicad file into a design """
# Rough'n'dirty parsing, assume nothing useful comes before
# the description
circuit = Design()
segments = set() # each wire segment
junctions = set() # wire junction point (connects all wires under it)
if library_filename is None:
library_filename = splitext(filename)[0] + '-cache.lib'
if exists(library_filename):
self.parse_library(library_filename, circuit)
f = open(filename)
# Read until the end of the description
while f.readline().strip() != "$EndDescr":
pass
# Now parse wires and components, ignore connections, we get
# connectivity from wire segments
line = f.readline()
while line:
element = line.split()[0] # whats next on the list
if element == "Wire": # Wire Segment, coords on 2nd line
x1, y1, x2, y2 = [int(i) for i in f.readline().split()]
if not (x1 == x2 and y1 == y2): # ignore zero-length segments
segments.add(((x1, y1), (x2, y2)))
elif element == "Connection": # Store these to apply later
x, y = [int(i) for i in line.split()[2:4]]
junctions.add((x, y))
elif element == "$Comp": # Component Instance
# name & reference
prefix, name, reference = f.readline().split()
assert prefix == 'L'
# timestamp
prefix, _ = f.readline().split(None, 1)
assert prefix == 'U'
# position
prefix, compx, compy = f.readline().split()
assert prefix == 'P'
compx, compy = int(compx), int(compy)
# TODO(ajray): ignore all the fields for now, probably
# could make these annotations
while f.readline().strip() not in ("$EndComp", ''):
pass
# TODO: calculate rotation
inst = ComponentInstance(reference, name, 0)
inst.add_symbol_attribute(SymbolAttribute(compx, compy, 0))
circuit.add_component_instance(inst)
line = f.readline()
f.close()
segments = self.divide(segments, junctions)
circuit.nets = self.calc_nets(segments)
return circuit