def _placeOutline(self):
"""
"""
# Place shape
shape_group = et.SubElement(self._layers['outline']['layer'], 'g')
shape_group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'module-shapes')
place.placeShape(self._outline, shape_group)
# Place a mask for the board's outline. This creates a buffer between
# the board's edge and pours
try:
pour_buffer = self._module['distances']['from-pour-to']['outline']
except:
pour_buffer = config.brd['distances']['from-pour-to']['outline']
for pcb_layer in utils.getSurfaceLayers():
if utils.checkForPoursInLayer(pcb_layer) is True:
mask_element = place.placeShape(self._outline,
self._masks[pcb_layer])
# Override style so that we get the desired effect
# We stroke the outline with twice the size of the buffer, so
# we get the actual distance between the outline and board
style = "fill:none;stroke:#000;stroke-linejoin:round;stroke-width:%s;" % str(
pour_buffer * 2)
mask_element.set('style', style)
# Also override mask's gerber-lp and set to all clear
path = self._outline.getOriginalPath().lower()
segments = path.count('m')
mask_element.set(
'{' + config.cfg['ns']['pcbmode'] + '}gerber-lp',
'c' * segments)
def _placeOutline(self):
"""
"""
# Place shape
shape_group = et.SubElement(self._layers['outline']['layer'], 'g')
shape_group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'module-shapes')
place.placeShape(self._outline, shape_group)
# Place a mask for the board's outline. This creates a buffer between
# the board's edge and pours
try:
pour_buffer = self._module['distances']['from-pour-to']['outline']
except:
pour_buffer = config.brd['distances']['from-pour-to']['outline']
for pcb_layer in config.stk['layer-names']:
if utils.checkForPoursInLayer(pcb_layer) is True:
mask_element = place.placeShape(self._outline, self._masks[pcb_layer])
# Override style so that we get the desired effect
# We stroke the outline with twice the size of the buffer, so
# we get the actual distance between the outline and board
style = "fill:none;stroke:#000;stroke-linejoin:round;stroke-width:%s;" % str(pour_buffer*2)
mask_element.set('style', style)
# Also override mask's gerber-lp and set to all clear
path = self._outline.getOriginalPath().lower()
segments = path.count('m')
mask_element.set('{'+config.cfg['ns']['pcbmode']+'}gerber-lp', 'c'*segments)
def _placeRouting(self):
"""
"""
routing = config.rte
routes = routing.get('routes') or {}
vias = routing.get('vias')
# Path effects are used for meandering paths, for example
path_effects = routes.get('path_effects')
xpath_expr = "//g[@inkscape:label='%s']//g[@inkscape:label='%s']"
extra_attributes = [
'inkscape:connector-curvature', 'inkscape:original-d',
'inkscape:path-effect'
]
for pcb_layer in utils.getSurfaceLayers():
# Are there pours in the layer? This makes a difference for whether to place
# masks
there_are_pours = utils.checkForPoursInLayer(pcb_layer)
# Define a group where masks are stored
mask_group = et.SubElement(self._masks[pcb_layer], 'g')
# Place defined routes on this SVG layer
sheet = self._layers[pcb_layer]['copper']['routing']['layer']
for route_key in (routes.get(pcb_layer) or {}):
shape_dict = routes[pcb_layer][route_key]
shape = Shape(shape_dict)
style = Style(shape_dict, 'copper')
shape.setStyle(style)
# Routes are a special case where they are used as-is
# counting on Inkscapes 'optimised' setting to modify
# the path such that placement is refleced in
# it. Therefor we use the original path, not the
# transformed one as usual
use_original_path = True
mirror_path = False
route_element = place.placeShape(shape, sheet, mirror_path,
use_original_path)
route_element.set('style', shape.getStyleString())
# Set the key as pcbmode:id of the route. This is used
# when extracting routing to offset the location of a
# modified route
route_element.set(
'{' + config.cfg['ns']['pcbmode'] + '}%s' % ('id'),
route_key)
# Add a custom buffer definition if it exists
custom_buffer = shape_dict.get('buffer-to-pour')
if custom_buffer != None:
route_element.set(
'{' + config.cfg['namespace']['pcbmode'] +
'}%s' % "buffer-to-pour", str(custom_buffer))
# TODO: can this be done more elegantly, and "general purpose"?
for extra_attrib in extra_attributes:
ea = shape_dict.get(extra_attrib)
if ea is not None:
route_element.set(
'{' + config.cfg['namespace']['inkscape'] + '}%s' %
(extra_attrib[extra_attrib.index(':') + 1:], ea))
# TODO: this needs to eventually go away or be done properly
pcbmode_params = shape_dict.get('pcbmode')
if pcbmode_params is not None:
route_element.set('pcbmode', pcbmode_params)
if ((there_are_pours == True) and (custom_buffer != "0")):
self._placeMask(self._masks[pcb_layer], shape, 'route',
use_original_path)
def _placeComponents(self, components, component_type, print_refdef=False):
"""
"""
for component in components:
shapes_dict = component.getShapes()
location = component.getLocation()
refdef = component.getRefdef()
if print_refdef == True:
print refdef,
# If the component is placed on the bottom layer we need
# to invert the shapes AND their 'x' coordinate. This is
# done using the 'invert' indicator set below
placement_layer = component.getPlacementLayer()
if placement_layer == 'bottom':
invert = True
else:
invert = False
for pcb_layer in utils.getSurfaceLayers():
there_are_pours = utils.checkForPoursInLayer(pcb_layer)
# Copper
shapes = shapes_dict['copper'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['copper']['pads'][
'layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
if component_type == 'components':
group.set(
'{' + config.cfg['ns']['pcbmode'] + '}refdef',
component.getRefdef())
elif component_type == 'vias':
group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'via')
group.set('{' + config.cfg['ns']['pcbmode'] + '}via',
component.getFootprintName())
else:
pass
for shape in shapes:
place.placeShape(shape, group, invert)
if there_are_pours == True:
mask_group = et.SubElement(self._masks[pcb_layer],
'g',
transform=transform)
self._placeMask(mask_group,
shape,
'pad',
original=False,
mirror=invert)
# Add pin labels
# There's a bit of a hack here that won't work in
# all possible cases (where pads are placed on
# bottom layer in a component that has pins placed
# both on the top and on the bottom -- a rare
# case). Good enough for now
labels = shapes_dict['pin-labels']['top'] #[pcb_layer]
if labels != []:
style = utils.dictToStyleText(
config.stl['layout']['board']['pad-labels'])
label_group = et.SubElement(
group,
'g',
transform="rotate(%s)" %
(((1, -1)[invert]) * component.getRotation()),
style=style)
for label in labels:
t = et.SubElement(label_group,
'text',
x=str(((1, -1)[invert]) *
label['location'][0]),
y=str(config.cfg['invert-y'] *
label['location'][1]))
t.text = label['text']
# Soldermask
shapes = shapes_dict['soldermask'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['soldermask']['layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Solderpaste
shapes = shapes_dict['solderpaste'][pcb_layer]
svg_layer = self._layers[pcb_layer]['solderpaste']['layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Silkscreen
shapes = shapes_dict['silkscreen'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['silkscreen']['layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
shape_group = et.SubElement(svg_layer,
'g',
transform=transform)
shape_group.set(
'{' + config.cfg['ns']['pcbmode'] + '}type',
'component-shapes')
for shape in shapes:
# Refdefs need to be in their own groups so that their
# location can later be extracted, hence this...
try:
is_refdef = getattr(shape, 'is_refdef')
except:
is_refdef = False
if is_refdef == True:
refdef_group = et.SubElement(svg_layer,
'g',
transform=transform)
refdef_group.set(
'{' + config.cfg['ns']['pcbmode'] + '}type',
'refdef')
refdef_group.set(
'{' + config.cfg['ns']['pcbmode'] + '}refdef',
refdef)
placed_element = place.placeShape(
shape, refdef_group, invert)
else:
placed_element = place.placeShape(
shape, shape_group, invert)
# Assembly
shapes = shapes_dict['assembly'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['assembly']['layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Drills
shapes = shapes_dict['drills'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers['drills']['layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
placed_element.set(
'{' + config.cfg['ns']['pcbmode'] + '}diameter',
str(shape.getDiameter()))
def _placeShapes(self):
"""
"""
mirror = False
try:
shapes_dict = self._module_dict['shapes']
except:
return
for sheet in ['copper', 'soldermask', 'solderpaste', 'silkscreen']:
try:
shapes = shapes_dict[sheet]
except KeyError:
continue
there_are_pours = {}
shape_groups = {}
for pcb_layer in utils.getSurfaceLayers():
there_are_pours[pcb_layer] = utils.checkForPoursInLayer(
pcb_layer)
shape_groups[pcb_layer] = et.SubElement(
self._layers[pcb_layer][sheet]['layer'], 'g')
shape_groups[pcb_layer].set(
'{' + config.cfg['ns']['pcbmode'] + '}type',
'module-shapes')
for shape_dict in shapes:
pcb_layers = shape_dict.get('layers') or ['top']
for pcb_layer in pcb_layers:
# Shapes placed on the bottom layer are not mirrored
# unless they are text, in which case, it's the
# expected behaviour and so it is mirrored by default
# unless otherwise instructed.
try:
shape_mirror = shape_dict.get['mirror']
except:
if shape_dict['type'] == 'text':
shape_mirror = True
else:
shape_mirror = False
if (pcb_layer == 'bottom') and (shape_mirror != False):
shape_dict['location'][0] *= -1
mirror = True
else:
mirror = False
shape = Shape(shape_dict)
style = Style(shape_dict, sheet)
shape.setStyle(style)
place.placeShape(shape, shape_groups[pcb_layer], mirror)
# Place mask for pour if copper shape
if (sheet == 'copper') and (there_are_pours[pcb_layer]
== True):
location = shape.getLocation()
transform = "translate(%s,%s)" % (location.x,
location.y)
mask_group = et.SubElement(self._masks[pcb_layer], 'g')
self._placeMask(svg_layer=mask_group,
shape=shape,
kind='pad',
original=False,
mirror=mirror)
def __init__(self, module_dict, routing_dict, asmodule=False):
"""
"""
self._module_dict = module_dict
self._routing_dict = routing_dict
self._outline = self._getOutline()
self._width = self._outline.getWidth()
self._height = self._outline.getHeight()
# Get dictionary of component definitions
components_dict = self._module_dict.get('components') or {}
self._components = self._getComponents(components_dict)
# Get dictionary of component definitions
vias_dict = self._routing_dict.get('vias') or {}
self._vias = self._getComponents(vias_dict)
sig_dig = config.cfg['significant-digits']
self._transform = 'translate(%s %s)' % (round(
self._width / 2, sig_dig), round(self._height / 2, sig_dig))
# Create the Inkscape SVG document
self._module = self._getModuleElement()
svg_doc = et.ElementTree(self._module)
# Get a dictionary of SVG layers
self._layers = svg.makeSvgLayers(self._module, self._transform)
# Add a 'defs' element:
# http://www.w3.org/TR/SVG/struct.html#Head
# This is where masking elements that are used for pours are stored
defs = et.SubElement(self._module, 'defs')
self._masks = {}
for pcb_layer in utils.getSurfaceLayers():
element = et.SubElement(defs,
'mask',
id="mask-%s" % pcb_layer,
transform=self._transform)
# This will identify the masks for each PCB layer when
# the layer is converted to Gerber
element.set('{' + config.cfg['ns']['pcbmode'] + '}pcb-layer',
pcb_layer)
self._masks[pcb_layer] = element
self._placeOutline()
self._placeOutlineDimensions()
msg.subInfo('Placing components:', newline=False)
self._placeComponents(self._components,
'components',
print_refdef=True)
print
msg.subInfo('Placing routes')
self._placeRouting()
msg.subInfo('Placing vias')
self._placeComponents(self._vias, 'vias')
msg.subInfo('Placing shapes')
self._placeShapes()
msg.subInfo('Placing pours')
self._placePours()
if config.tmp['no-docs'] == False:
msg.subInfo('Placing documentation')
self._placeDocs()
if config.tmp['no-drill-index'] == False:
msg.subInfo('Placing drill index')
self._placeDrillIndex()
if config.tmp['no-layer-index'] == False:
msg.subInfo('Placing layer index')
self._placeLayerIndex()
# This 'cover' "enables" the mask shapes defined in the mask are
# shown. It *must* be the last element in the mask definition;
# any mask element after it won't show
for pcb_layer in utils.getSurfaceLayers():
if utils.checkForPoursInLayer(pcb_layer) is True:
mask_cover = et.SubElement(self._masks[pcb_layer],
'rect',
x="%s" % str(-self._width / 2),
y="%s" % str(-self._height / 2),
width="%s" % self._width,
height="%s" % self._height,
style="fill:#fff;")
# This tells the Gerber conversion to ignore this shape
mask_cover.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'mask-cover')
output_file = os.path.join(config.cfg['base-dir'],
config.cfg['locations']['build'],
config.cfg['name'] + '.svg')
try:
f = open(output_file, 'wb')
except IOError as e:
print "I/O error({0}): {1}".format(e.errno, e.strerror)
f.write(et.tostring(svg_doc, pretty_print=True))
f.close()
def _placeRouting(self):
"""
"""
routing = config.rte
routes = routing.get('routes') or {}
# Path effects are used for meandering paths, for example
path_effects = routes.get('path_effects')
xpath_expr = "//g[@inkscape:label='%s']//g[@inkscape:label='%s']"
extra_attributes = ['inkscape:connector-curvature', 'inkscape:original-d', 'inkscape:path-effect']
for pcb_layer in config.stk['layer-names']:
# Are there pours in the layer? This makes a difference for whether to place
# masks
there_are_pours = utils.checkForPoursInLayer(pcb_layer)
# Define a group where masks are stored
mask_group = et.SubElement(self._masks[pcb_layer], 'g')
# Place defined routes on this SVG layer
sheet = self._layers[pcb_layer]['conductor']['routing']['layer']
for route_key in (routes.get(pcb_layer) or {}):
shape_dict = routes[pcb_layer][route_key]
shape = Shape(shape_dict)
style = Style(shape_dict, 'conductor')
shape.setStyle(style)
# Routes are a special case where they are used as-is
# counting on Inkscapes 'optimised' setting to modify
# the path such that placement is refleced in
# it. Therefor we use the original path, not the
# transformed one as usual
use_original_path = True
mirror_path = False
route_element = place.placeShape(shape,
sheet,
mirror_path,
use_original_path)
route_element.set('style', shape.getStyleString())
# Set the key as pcbmode:id of the route. This is used
# when extracting routing to offset the location of a
# modified route
route_element.set('{'+config.cfg['ns']['pcbmode']+'}%s' % ('id'),
route_key)
# Add a custom buffer definition if it exists
custom_buffer = shape_dict.get('buffer-to-pour')
if custom_buffer != None:
route_element.set('{'+config.cfg['namespace']['pcbmode']+'}%s' % "buffer-to-pour", str(custom_buffer))
# TODO: can this be done more elegantly, and "general purpose"?
for extra_attrib in extra_attributes:
ea = shape_dict.get(extra_attrib)
if ea is not None:
route_element.set('{'+config.cfg['namespace']['inkscape']+'}%s' % (extra_attrib[extra_attrib.index(':')+1:], ea))
# TODO: this needs to eventually go away or be done properly
pcbmode_params = shape_dict.get('pcbmode')
if pcbmode_params is not None:
route_element.set('pcbmode', pcbmode_params)
if ((there_are_pours == True) and (custom_buffer != "0")):
self._placeMask(self._masks[pcb_layer],
shape,
'route',
use_original_path)
def _placeComponents(self, components, component_type, print_refdef=False):
"""
Places the component on the board.
'component_type' is the content of the 'type' fiels of the
placed group. This is used by the extractor to identify the
type of component ('component', 'via', 'shape')
"""
htmlpar = HTMLParser.HTMLParser()
for component in components:
shapes_dict = component.getShapes()
location = component.getLocation()
rotation = component.getRotation()
refdef = component.getRefdef()
if print_refdef == True:
print refdef,
# If the component is placed on the bottom layer we need
# to invert the shapes AND their 'x' coordinate. This is
# done using the 'invert' indicator set below
placement_layer = component.getPlacementLayer()
if placement_layer == 'bottom':
invert = True
else:
invert = False
for pcb_layer in config.stk['layer-names']:
there_are_pours = utils.checkForPoursInLayer(pcb_layer)
# Copper
shapes = shapes_dict['conductor'].get(pcb_layer) or []
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['conductor']['pads']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
shape_group = et.SubElement(svg_layer, 'g',
transform=transform)
shape_group.set('{'+config.cfg['ns']['pcbmode']+'}type', component_type)
# Add the reference designator as well if it's a
# 'component'
if component_type == 'component':
shape_group.set('{'+config.cfg['ns']['pcbmode']+'}refdef', component.getRefdef())
style = utils.dictToStyleText(config.stl['layout']['conductor']['pads']['labels'])
label_group = et.SubElement(shape_group, 'g', style=style)
for shape in shapes:
place.placeShape(shape, shape_group, invert)
# Add pin labels
# TODO: This isn't perfect, but good enough for now
label = shape.getLabel()
if label != None:
label_location = shape.getLocation()
label_rotation = shape.getRotation()
label_transform = "rotate(%s)" % label_rotation
t = et.SubElement(label_group, 'text',
x=str(((1,-1)[invert])*label_location.x),
y=str(config.cfg['invert-y']*label_location.y),
transform=label_transform)
t.text = label
if there_are_pours == True:
mask_group = et.SubElement(self._masks[pcb_layer], 'g',
transform=transform)
self._placeMask(mask_group,
shape,
'pad',
original=False,
mirror=invert)
# Pours
shapes = shapes_dict['pours'].get(pcb_layer) or []
try:
svg_layer = self._layers[pcb_layer]['conductor']['pours']['layer']
shape_group = et.SubElement(svg_layer, 'g',
mask='url(#mask-%s)' % pcb_layer)
except:
svg_layer = None
if len(shapes) > 0 and svg_layer != None:
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(shape_group, 'g', transform=transform)
group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'pours')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Soldermask
shapes = shapes_dict['soldermask'].get(pcb_layer) or []
try:
svg_layer = self._layers[pcb_layer]['soldermask']['layer']
except:
svg_layer = None
if len(shapes) > 0 and svg_layer != None:
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Solderpaste
shapes = shapes_dict['solderpaste'].get(pcb_layer) or []
try:
svg_layer = self._layers[pcb_layer]['solderpaste']['layer']
except:
svg_layer = None
if len(shapes) > 0 and svg_layer != None:
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Silkscreen
shapes = shapes_dict['silkscreen'].get(pcb_layer) or []
try:
svg_layer = self._layers[pcb_layer]['silkscreen']['layer']
except:
svg_layer = None
if len(shapes) > 0 and svg_layer != None:
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
shape_group = et.SubElement(svg_layer, 'g', transform=transform)
shape_group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
for shape in shapes:
# Refdefs need to be in their own groups so that their
# location can later be extracted, hence this...
try:
is_refdef = getattr(shape, 'is_refdef')
except:
is_refdef = False
if is_refdef == True:
# Shapes don't need to have silkscreen
# reference designators
if component_type != 'shape':
refdef_group = et.SubElement(svg_layer, 'g', transform=transform)
refdef_group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'refdef')
refdef_group.set('{'+config.cfg['ns']['pcbmode']+'}refdef', refdef)
placed_element = place.placeShape(shape, refdef_group, invert)
else:
placed_element = place.placeShape(shape, shape_group, invert)
# Assembly
shapes = shapes_dict['assembly'].get(pcb_layer) or []
try:
svg_layer = self._layers[pcb_layer]['assembly']['layer']
except:
svg_layer = None
if len(shapes) > 0 and svg_layer != None:
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Drills
shapes = shapes_dict['drills'].get(pcb_layer) or []
if len(shapes) > 0:
svg_layer = self._layers['drills']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
placed_element.set('{'+config.cfg['ns']['pcbmode']+'}diameter',
str(shape.getDiameter()))
# Place component origin marker
svg_layer = self._layers[placement_layer]['placement']['layer']
# Here pcb_layer may not exist for components that define
# shapes for internal layers but only surface layers are
# defined in the stackup
try:
group = et.SubElement(svg_layer, 'g', transform=transform)
except:
return
group.set('{'+config.cfg['ns']['pcbmode']+'}type', component_type)
group.set('{'+config.cfg['ns']['pcbmode']+'}footprint', component.getFootprintName())
if (component_type == 'component') or (component_type == 'shape'):
group.set('{'+config.cfg['ns']['pcbmode']+'}refdef', refdef)
path = svg.placementMarkerPath()
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
if placement_layer == 'bottom':
rotation *= -1
marker_element = et.SubElement(group, 'path',
d=path,
transform="rotate(%s)" % rotation)
if (component_type == 'component'):
style = utils.dictToStyleText(config.stl['layout']['placement']['text'])
t = et.SubElement(group, 'text', x="0", y="-0.17", style=style)
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = "%s" % (refdef)
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = htmlpar.unescape("%s°" % (rotation))
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = "[%.2f,%.2f]" % (location[0], location[1])
elif (component_type == 'shape'):
style = utils.dictToStyleText(config.stl['layout']['placement']['text'])
t = et.SubElement(group, 'text', x="0", y="-0.17", style=style)
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = "%s" % (refdef)
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = htmlpar.unescape("%s°" % (rotation))
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = "[%.2f,%.2f]" % (location[0], location[1])
elif (component_type == 'via'):
style = utils.dictToStyleText(config.stl['layout']['placement']['text'])
t = et.SubElement(group, 'text', x="0", y="-0.11", style=style)
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = htmlpar.unescape("%s°" % (rotation))
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = "[%.2f,%.2f]" % (location[0], location[1])
else:
continue
def __init__(self,
module_dict,
routing_dict,
asmodule=False):
"""
"""
self._module_dict = module_dict
self._routing_dict = routing_dict
self._outline = self._getOutline()
self._width = self._outline.getWidth()
self._height = self._outline.getHeight()
# Get dictionary of component definitions
components_dict = self._module_dict.get('components') or {}
self._components = self._getComponents(components_dict)
# Get dictionary of component definitions
vias_dict = self._routing_dict.get('vias') or {}
self._vias = self._getComponents(vias_dict)
# Get dictionary of component definitions
shapes_dict = self._module_dict.get('shapes') or {}
self._shapes = self._getComponents(shapes_dict)
sig_dig = config.cfg['significant-digits']
self._transform = 'translate(%s %s)' % (round(self._width/2, sig_dig),
round(self._height/2, sig_dig))
# Create the Inkscape SVG document
self._module = self._getModuleElement()
svg_doc = et.ElementTree(self._module)
# Get a dictionary of SVG layers
self._layers = svg.makeSvgLayers(self._module, self._transform)
# Add a 'defs' element:
# http://www.w3.org/TR/SVG/struct.html#Head
# This is where masking elements that are used for pours are stored
defs = et.SubElement(self._module, 'defs')
self._masks = {}
for pcb_layer in config.stk['layer-names']:
element = et.SubElement(defs, 'mask',
id="mask-%s" % pcb_layer,
transform=self._transform)
# This will identify the masks for each PCB layer when
# the layer is converted to Gerber
element.set('{'+config.cfg['ns']['pcbmode']+'}pcb-layer', pcb_layer)
self._masks[pcb_layer] = element
self._placeOutline()
self._placeOutlineDimensions()
msg.subInfo('Placing components:', newline=False)
self._placeComponents(components=self._components,
component_type='component',
print_refdef=True)
print
msg.subInfo('Placing routes')
self._placeRouting()
msg.subInfo('Placing vias')
self._placeComponents(components=self._vias,
component_type='via',
print_refdef=False)
msg.subInfo('Placing shapes')
self._placeComponents(components=self._shapes,
component_type='shape',
print_refdef=False)
if config.tmp['no-docs'] == False:
msg.subInfo('Placing documentation')
self._placeDocs()
if config.tmp['no-drill-index'] == False:
msg.subInfo('Placing drill index')
self._placeDrillIndex()
if config.tmp['no-layer-index'] == False:
msg.subInfo('Placing layer index')
self._placeLayerIndex()
# This 'cover' "enables" the mask shapes defined in the mask are
# shown. It *must* be the last element in the mask definition;
# any mask element after it won't show
for pcb_layer in config.stk['layer-names']:
if utils.checkForPoursInLayer(pcb_layer) is True:
mask_cover = et.SubElement(self._masks[pcb_layer], 'rect',
x="%s" % str(-self._width/2),
y="%s" % str(-self._height/2),
width="%s" % self._width,
height="%s" % self._height,
style="fill:#fff;")
# This tells the Gerber conversion to ignore this shape
mask_cover.set('{'+config.cfg['ns']['pcbmode']+'}type', 'mask-cover')
output_file = os.path.join(config.cfg['base-dir'],
config.cfg['locations']['build'],
config.cfg['name'] + '.svg')
try:
f = open(output_file, 'wb')
except IOError as e:
print "I/O error({0}): {1}".format(e.errno, e.strerror)
f.write(et.tostring(svg_doc, pretty_print=True))
f.close()
def _placeComponents(self, components, component_type, print_refdef=False):
"""
"""
for component in components:
shapes_dict = component.getShapes()
location = component.getLocation()
# If the component is placed on the bottom layer we need
# to invert the shapes AND their 'x' coordinate. This is
# sone using the 'invert' indicator set below
refdef = component.getRefdef()
if print_refdef == True:
print refdef,
placement_layer = component.getPlacementLayer()
if placement_layer == 'bottom':
invert = True
else:
invert = False
for pcb_layer in utils.getSurfaceLayers():
there_are_pours = utils.checkForPoursInLayer(pcb_layer)
# Copper
shapes = shapes_dict['copper'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['copper']['pads'][
'layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
if component_type == 'components':
group.set(
'{' + config.cfg['ns']['pcbmode'] + '}refdef',
component.getRefdef())
elif component_type == 'vias':
group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'via')
group.set('{' + config.cfg['ns']['pcbmode'] + '}via',
component.getFootprintName())
else:
pass
for shape in shapes:
place.placeShape(shape, group)
if there_are_pours == True:
mask_group = et.SubElement(self._masks[pcb_layer],
'g',
transform=transform)
self._placeMask(mask_group, shape, 'pad')
# Add pin labels
labels = shapes_dict['pin-labels'][pcb_layer]
if labels != []:
style = utils.dictToStyleText(
config.stl['layout']['board']['pad-labels'])
label_group = et.SubElement(group,
'g',
transform="rotate(%s)" %
component.getRotation(),
style=style)
for label in labels:
t = et.SubElement(
label_group,
'text',
x=str(label['location'][0]),
# TODO: get rid of this hack
y=str(-label['location'][1]))
#y=str(-pin_location.y + pad_numbers_font_size/3),
#refdef=self._refdef)
t.text = label['text']
# Soldermask
shapes = shapes_dict['soldermask'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['soldermask']['layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group)
# Solderpaste
shapes = shapes_dict['solderpaste'][pcb_layer]
svg_layer = self._layers[pcb_layer]['solderpaste']['layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group)
# Silkscreen
shapes = shapes_dict['silkscreen'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['silkscreen']['layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
shape_group = et.SubElement(svg_layer,
'g',
transform=transform)
shape_group.set(
'{' + config.cfg['ns']['pcbmode'] + '}type',
'component-shapes')
for shape in shapes:
# Refdefs need to be in their own groups so that their
# location can later be extracted, hence this...
try:
is_refdef = getattr(shape, 'is_refdef')
except:
is_refdef = False
if is_refdef == True:
refdef_group = et.SubElement(svg_layer,
'g',
transform=transform)
refdef_group.set(
'{' + config.cfg['ns']['pcbmode'] + '}type',
'refdef')
refdef_group.set(
'{' + config.cfg['ns']['pcbmode'] + '}refdef',
refdef)
placed_element = place.placeShape(
shape, refdef_group)
else:
placed_element = place.placeShape(
shape, shape_group)
# Assembly
shapes = shapes_dict['assembly'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['assembly']['layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
for shape in shapes:
placed_element = place.placeShape(shape, group)
# Drills
shapes = shapes_dict['drills'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers['drills']['layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group)
placed_element.set(
'{' + config.cfg['ns']['pcbmode'] + '}diameter',
str(shape.getDiameter()))
def _placeComponents(self, components, component_type, print_refdef=False):
"""
"""
for component in components:
shapes_dict = component.getShapes()
location = component.getLocation()
refdef = component.getRefdef()
if print_refdef == True:
print refdef,
# If the component is placed on the bottom layer we need
# to invert the shapes AND their 'x' coordinate. This is
# done using the 'invert' indicator set below
placement_layer = component.getPlacementLayer()
if placement_layer == 'bottom':
invert = True
else:
invert = False
for pcb_layer in utils.getSurfaceLayers():
there_are_pours = utils.checkForPoursInLayer(pcb_layer)
# Copper
shapes = shapes_dict['copper'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['copper']['pads']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g',
transform=transform)
if component_type == 'components':
group.set('{'+config.cfg['ns']['pcbmode']+'}refdef', component.getRefdef())
elif component_type == 'vias':
group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'via')
group.set('{'+config.cfg['ns']['pcbmode']+'}via', component.getFootprintName())
else:
pass
for shape in shapes:
place.placeShape(shape, group, invert)
if there_are_pours == True:
mask_group = et.SubElement(self._masks[pcb_layer], 'g',
transform=transform)
self._placeMask(mask_group,
shape,
'pad',
original=False,
mirror=invert)
# Add pin labels
# There's a bit of a hack here that won't work in
# all possible cases (where pads are placed on
# bottom layer in a component that has pins placed
# both on the top and on the bottom -- a rare
# case). Good enough for now
labels = shapes_dict['pin-labels']['top']#[pcb_layer]
if labels != []:
style = utils.dictToStyleText(config.stl['layout']['board']['pad-labels'])
label_group = et.SubElement(group, 'g',
transform="rotate(%s)" % (((1,-1)[invert])*component.getRotation()),
style=style)
for label in labels:
t = et.SubElement(label_group, 'text',
x=str(((1,-1)[invert])*label['location'][0]),
y=str(config.cfg['invert-y']*label['location'][1]))
t.text = label['text']
# Soldermask
shapes = shapes_dict['soldermask'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['soldermask']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Solderpaste
shapes = shapes_dict['solderpaste'][pcb_layer]
svg_layer = self._layers[pcb_layer]['solderpaste']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Silkscreen
shapes = shapes_dict['silkscreen'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['silkscreen']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
shape_group = et.SubElement(svg_layer, 'g', transform=transform)
shape_group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
for shape in shapes:
# Refdefs need to be in their own groups so that their
# location can later be extracted, hence this...
try:
is_refdef = getattr(shape, 'is_refdef')
except:
is_refdef = False
if is_refdef == True:
refdef_group = et.SubElement(svg_layer, 'g', transform=transform)
refdef_group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'refdef')
refdef_group.set('{'+config.cfg['ns']['pcbmode']+'}refdef', refdef)
placed_element = place.placeShape(shape, refdef_group, invert)
else:
placed_element = place.placeShape(shape, shape_group, invert)
# Assembly
shapes = shapes_dict['assembly'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['assembly']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Drills
shapes = shapes_dict['drills'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers['drills']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group)
placed_element.set('{'+config.cfg['ns']['pcbmode']+'}diameter',
str(shape.getDiameter()))
def _placeShapes(self):
"""
"""
mirror = False
try:
shapes_dict = self._module_dict['shapes']
except:
return
for sheet in ['copper','soldermask','solderpaste','silkscreen']:
try:
shapes = shapes_dict[sheet]
except KeyError:
continue
there_are_pours = {}
shape_groups = {}
for pcb_layer in utils.getSurfaceLayers():
there_are_pours[pcb_layer] = utils.checkForPoursInLayer(pcb_layer)
shape_groups[pcb_layer] = et.SubElement(self._layers[pcb_layer][sheet]['layer'], 'g')
shape_groups[pcb_layer].set('{'+config.cfg['ns']['pcbmode']+'}type', 'module-shapes')
for shape_dict in shapes:
pcb_layers = shape_dict.get('layers') or ['top']
for pcb_layer in pcb_layers:
# Shapes placed on the bottom layer are not mirrored
# unless they are text, in which case, it's the
# expected behaviour and so it is mirrored by default
# unless otherwise instructed.
try:
shape_mirror = shape_dict.get['mirror']
except:
if shape_dict['type'] == 'text':
shape_mirror = True
else:
shape_mirror = False
if (pcb_layer == 'bottom') and (shape_mirror != False):
mirror = True
else:
mirror = False
shape = Shape(shape_dict)
style = Style(shape_dict, sheet)
shape.setStyle(style)
place.placeShape(shape, shape_groups[pcb_layer], mirror)
# Place mask for pour if copper shape
if (sheet == 'copper') and (there_are_pours[pcb_layer] == True):
location = shape.getLocation()
transform = "translate(%s,%s)" % (location.x, location.y)
mask_group = et.SubElement(self._masks[pcb_layer], 'g')
#id="routing_masks")
#transform=transform)
self._placeMask(svg_layer=mask_group,
shape=shape,
kind='pad',
original=False,
mirror=False)
def _placeComponents(self, components, component_type, print_refdef=False):
"""
Places the component on the board.
'component_type' is the content of the 'type' fiels of the
placed group. This is used by the extractor to identify the
type of component ('component', 'via', 'shape')
"""
htmlpar = HTMLParser.HTMLParser()
for component in components:
shapes_dict = component.getShapes()
location = component.getLocation()
rotation = component.getRotation()
refdef = component.getRefdef()
if print_refdef == True:
print refdef,
# If the component is placed on the bottom layer we need
# to invert the shapes AND their 'x' coordinate. This is
# done using the 'invert' indicator set below
placement_layer = component.getPlacementLayer()
if placement_layer == 'bottom':
invert = True
else:
invert = False
for pcb_layer in config.stk['layer-names']:
there_are_pours = utils.checkForPoursInLayer(pcb_layer)
# Copper
shapes = shapes_dict['conductor'].get(pcb_layer) or []
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['conductor']['pads'][
'layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
shape_group = et.SubElement(svg_layer,
'g',
transform=transform)
shape_group.set(
'{' + config.cfg['ns']['pcbmode'] + '}type',
component_type)
# Add the reference designator as well if it's a
# 'component'
if component_type == 'component':
shape_group.set(
'{' + config.cfg['ns']['pcbmode'] + '}refdef',
component.getRefdef())
style = utils.dictToStyleText(
config.stl['layout']['conductor']['pads']['labels'])
label_group = et.SubElement(shape_group, 'g', style=style)
for shape in shapes:
place.placeShape(shape, shape_group, invert)
# Add pin labels
# TODO: This isn't perfect, but good enough for now
label = shape.getLabel()
if label != None:
label_location = shape.getLocation()
label_rotation = shape.getRotation()
label_transform = "rotate(%s)" % label_rotation
t = et.SubElement(label_group,
'text',
x=str(((1, -1)[invert]) *
label_location.x),
y=str(config.cfg['invert-y'] *
label_location.y),
transform=label_transform)
t.text = label
if there_are_pours == True:
mask_group = et.SubElement(self._masks[pcb_layer],
'g',
transform=transform)
self._placeMask(mask_group,
shape,
'pad',
original=False,
mirror=invert)
# Pours
shapes = shapes_dict['pours'].get(pcb_layer) or []
try:
svg_layer = self._layers[pcb_layer]['conductor']['pours'][
'layer']
shape_group = et.SubElement(svg_layer,
'g',
mask='url(#mask-%s)' %
pcb_layer)
except:
svg_layer = None
if len(shapes) > 0 and svg_layer != None:
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(shape_group,
'g',
transform=transform)
group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'pours')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Soldermask
shapes = shapes_dict['soldermask'].get(pcb_layer) or []
try:
svg_layer = self._layers[pcb_layer]['soldermask']['layer']
except:
svg_layer = None
if len(shapes) > 0 and svg_layer != None:
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Solderpaste
shapes = shapes_dict['solderpaste'].get(pcb_layer) or []
try:
svg_layer = self._layers[pcb_layer]['solderpaste']['layer']
except:
svg_layer = None
if len(shapes) > 0 and svg_layer != None:
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Silkscreen
shapes = shapes_dict['silkscreen'].get(pcb_layer) or []
try:
svg_layer = self._layers[pcb_layer]['silkscreen']['layer']
except:
svg_layer = None
if len(shapes) > 0 and svg_layer != None:
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
shape_group = et.SubElement(svg_layer,
'g',
transform=transform)
shape_group.set(
'{' + config.cfg['ns']['pcbmode'] + '}type',
'component-shapes')
for shape in shapes:
# Refdefs need to be in their own groups so that their
# location can later be extracted, hence this...
try:
is_refdef = getattr(shape, 'is_refdef')
except:
is_refdef = False
if is_refdef == True:
# Shapes don't need to have silkscreen
# reference designators
if component_type != 'shape':
refdef_group = et.SubElement(
svg_layer, 'g', transform=transform)
refdef_group.set(
'{' + config.cfg['ns']['pcbmode'] +
'}type', 'refdef')
refdef_group.set(
'{' + config.cfg['ns']['pcbmode'] +
'}refdef', refdef)
placed_element = place.placeShape(
shape, refdef_group, invert)
else:
placed_element = place.placeShape(
shape, shape_group, invert)
# Assembly
shapes = shapes_dict['assembly'].get(pcb_layer) or []
try:
svg_layer = self._layers[pcb_layer]['assembly']['layer']
except:
svg_layer = None
if len(shapes) > 0 and svg_layer != None:
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Drills
shapes = shapes_dict['drills'].get(pcb_layer) or []
if len(shapes) > 0:
svg_layer = self._layers['drills']['layer']
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
placed_element.set(
'{' + config.cfg['ns']['pcbmode'] + '}diameter',
str(shape.getDiameter()))
# Place component origin marker
svg_layer = self._layers[placement_layer]['placement']['layer']
# Here pcb_layer may not exist for components that define
# shapes for internal layers but only surface layers are
# defined in the stackup
try:
group = et.SubElement(svg_layer, 'g', transform=transform)
except:
return
group.set('{' + config.cfg['ns']['pcbmode'] + '}type',
component_type)
group.set('{' + config.cfg['ns']['pcbmode'] + '}footprint',
component.getFootprintName())
if (component_type == 'component') or (component_type == 'shape'):
group.set('{' + config.cfg['ns']['pcbmode'] + '}refdef',
refdef)
path = svg.placementMarkerPath()
transform = "translate(%s,%s)" % (
location[0], config.cfg['invert-y'] * location[1])
if placement_layer == 'bottom':
rotation *= -1
marker_element = et.SubElement(group,
'path',
d=path,
transform="rotate(%s)" % rotation)
if (component_type == 'component'):
style = utils.dictToStyleText(
config.stl['layout']['placement']['text'])
t = et.SubElement(group, 'text', x="0", y="-0.17", style=style)
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = "%s" % (refdef)
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = htmlpar.unescape("%s°" % (rotation))
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = "[%.2f,%.2f]" % (location[0], location[1])
elif (component_type == 'shape'):
style = utils.dictToStyleText(
config.stl['layout']['placement']['text'])
t = et.SubElement(group, 'text', x="0", y="-0.17", style=style)
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = "%s" % (refdef)
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = htmlpar.unescape("%s°" % (rotation))
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = "[%.2f,%.2f]" % (location[0], location[1])
elif (component_type == 'via'):
style = utils.dictToStyleText(
config.stl['layout']['placement']['text'])
t = et.SubElement(group, 'text', x="0", y="-0.11", style=style)
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = htmlpar.unescape("%s°" % (rotation))
ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
ts.text = "[%.2f,%.2f]" % (location[0], location[1])
else:
continue
def _placeComponents(self, components, component_type, print_refdef=False):
"""
"""
for component in components:
shapes_dict = component.getShapes()
location = component.getLocation()
# If the component is placed on the bottom layer we need
# to invert the shapes AND their 'x' coordinate. This is
# sone using the 'invert' indicator set below
refdef = component.getRefdef()
if print_refdef == True:
print refdef,
placement_layer = component.getPlacementLayer()
if placement_layer == 'bottom':
invert = True
else:
invert = False
for pcb_layer in utils.getSurfaceLayers():
there_are_pours = utils.checkForPoursInLayer(pcb_layer)
# Copper
shapes = shapes_dict['copper'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['copper']['pads']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g',
transform=transform)
if component_type == 'components':
group.set('{'+config.cfg['ns']['pcbmode']+'}refdef', component.getRefdef())
elif component_type == 'vias':
group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'via')
group.set('{'+config.cfg['ns']['pcbmode']+'}via', component.getFootprintName())
else:
pass
for shape in shapes:
place.placeShape(shape, group)
if there_are_pours == True:
mask_group = et.SubElement(self._masks[pcb_layer], 'g',
transform=transform)
self._placeMask(mask_group,
shape,
'pad')
# Add pin labels
labels = shapes_dict['pin-labels'][pcb_layer]
if labels != []:
style = utils.dictToStyleText(config.stl['layout']['board']['pad-labels'])
label_group = et.SubElement(group, 'g',
transform="rotate(%s)" % component.getRotation(),
style=style)
for label in labels:
t = et.SubElement(label_group, 'text',
x=str(label['location'][0]),
# TODO: get rid of this hack
y=str(-label['location'][1]))
#y=str(-pin_location.y + pad_numbers_font_size/3),
#refdef=self._refdef)
t.text = label['text']
# Soldermask
shapes = shapes_dict['soldermask'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['soldermask']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group)
# Solderpaste
shapes = shapes_dict['solderpaste'][pcb_layer]
svg_layer = self._layers[pcb_layer]['solderpaste']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group, invert)
# Silkscreen
shapes = shapes_dict['silkscreen'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['silkscreen']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
shape_group = et.SubElement(svg_layer, 'g', transform=transform)
shape_group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
for shape in shapes:
# Refdefs need to be in their own groups so that their
# location can later be extracted, hence this...
try:
is_refdef = getattr(shape, 'is_refdef')
except:
is_refdef = False
if is_refdef == True:
refdef_group = et.SubElement(svg_layer, 'g', transform=transform)
refdef_group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'refdef')
refdef_group.set('{'+config.cfg['ns']['pcbmode']+'}refdef', refdef)
placed_element = place.placeShape(shape, refdef_group)
else:
placed_element = place.placeShape(shape, shape_group)
# Assembly
shapes = shapes_dict['assembly'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers[pcb_layer]['assembly']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
for shape in shapes:
placed_element = place.placeShape(shape, group)
# Drills
shapes = shapes_dict['drills'][pcb_layer]
if len(shapes) > 0:
svg_layer = self._layers['drills']['layer']
transform = "translate(%s,%s)" % (location[0],
config.cfg['invert-y']*location[1])
group = et.SubElement(svg_layer, 'g', transform=transform)
group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
for shape in shapes:
placed_element = place.placeShape(shape, group)
placed_element.set('{'+config.cfg['ns']['pcbmode']+'}diameter',
str(shape.getDiameter()))
