def contour(vectors, width):
vectors = [numeric.Vector(v) for v in vectors]
width = numeric.Scalar(width)
radius = width / 2
block = graphic.Block()
# iterate and generate rectangles
for vector_idx in range(len(vectors) - 1):
v1 = vectors[vector_idx]
v2 = vectors[vector_idx + 1]
if v1[0] == v2[0]:
# vertical
center = numeric.Vector((v1[0], (v1[1] + v2[1]) / 2))
trace_len = numeric.Scalar(val=abs(v1[1] - v2[1]))
block += rect(center, width, trace_len + width)
elif v1[1] == v2[1]:
# horizontal
center = numeric.Vector(((v1[0] + v2[0]) / 2, v1[1]))
trace_len = numeric.Scalar(val=abs(v1[0] - v2[0]))
block += rect(center, trace_len + width, width)
else:
raise Exception()
return block
def __init__(self, vectors, interp_mode=None, quad_mode=None, center=None):
vectors = (numeric.Vector(vectors[0]), numeric.Vector(vectors[1]))
if interp_mode is None: interp_mode = gbrtypes.Linear()
if quad_mode is None: quad_mode = gbrtypes.Auto()
self.vectors = vectors
self.interp_mode = interp_mode
self.quad_mode = quad_mode
self.center = center
def circle(center, radius):
circ_vector = numeric.Vector(center + numeric.Vector((radius, 0)))
region = graphic.Region([
graphic.Segment((circ_vector, circ_vector),
gbrtypes.CounterClockwise(),
center=center),
])
return region
def s_logo(center, width):
center = numeric.Vector(center)
width = numeric.Scalar(width)
radius = width / 2
trace_width = width * LOGO_TRACE_RATIO
logo = graphic.Block()
square_offset = (width / 4, width - trace_width - width / 4)
ring_top = ring(center + (0, width - trace_width), radius, trace_width)
ring_top -= square(center + square_offset, width / 2)
ring_bot = ring(center - (0, width - trace_width), radius, trace_width)
ring_bot -= square(center - square_offset, width / 2)
ring_mid = ring(center, radius, trace_width)
dot = circle(center, radius * CIRC_MID_RATIO)
logo += ring_top
logo += ring_bot
logo += ring_mid
logo += dot
return logo
def move(self, stream, vector):
vector = numeric.Vector(vector)
# if not already at vector, generate Move command
if not self.state.vector == vector:
stream.append(command.Move(vector))
self.state.vector = vector
def __init__(self, segments=list(), polarity=None):
GraphicObject.__init__(self, polarity)
self.aperture_attributes = gbrtypes.ApertureAttributes()
self.segments = list()
# normalize segments to form closed region
if len(segments) > 0:
if type(segments[0]) is Segment:
# append given segments
self.segments += segments
else:
# assemble simple polygon from vectors
vectors = segments
# normalize vectors
vectors = [numeric.Vector(vector) for vector in vectors]
for idx in range(len(vectors) - 1):
self.segments.append(Segment((vectors[idx], vectors[idx + 1])))
# closing segment
self.segments.append(Segment((vectors[-1], vectors[0])))
def s_logo_ckt(center, width, pad_count, soldermask):
center = numeric.Vector(center)
width = numeric.Scalar(width)
ckt = graphic.Block()
ckt += s_logo(center, width)
ckt += LogoCkt(center, width, pad_count, soldermask)
return ckt
def flash(self, stream, ap, vector):
vector = numeric.Vector(vector)
if not self.state.current_aperture == ap:
# set aperture
stream.append(command.SetAperture(ap))
self.state.current_aperture = ap
stream.append(command.Flash(vector))
def interpolate(self, stream, vector):
vector = numeric.Vector(vector)
# get offset, if applicable
if issubclass(type(self.state.interp_mode), gbrtypes.Circular):
# create vector of signed diff
offset = numeric.Vector(
(self.state.center.val[0] - self.state.vector.val[0],
self.state.center.val[1] - self.state.vector.val[1]))
# check if offsets are unsigned
if self.state.quad_mode == gbrtypes.Single: offset = abs(offset)
else:
offset = None
# generate Interpolate command
stream.append(command.Interpolate(vector, offset))
# update current vector
self.state.vector = vector
def trace(vectors, width, clearance=0.):
vectors = [numeric.Vector(v) for v in vectors]
width = numeric.Scalar(width)
clearance = numeric.Scalar(clearance)
block = graphic.Block()
# generate clearance for all traces
if clearance != 0:
block -= contour(vectors, width + clearance * 2)
# generate traces
block += contour(vectors, width)
return block
def set_interp(self, stream, interp_mode, center=None):
# note: center only valid for Circular interp mode
if not center is None:
self.state.center = numeric.Vector(center)
if not self.state.interp_mode == interp_mode:
logging.debug('Setting interpolation: ' + str(interp_mode))
if interp_mode == gbrtypes.Linear:
stream.append(command.SetInterpLinear())
elif interp_mode == gbrtypes.Clockwise:
stream.append(command.SetInterpClockwise())
elif interp_mode == gbrtypes.CounterClockwise:
stream.append(command.SetInterpCounterClockwise())
else:
raise Exception('Invalid interpolation mode: ' +
str(interp_mode))
self.state.interp_mode = interp_mode
def __init__(self, center, width, pad_count, soldermask):
graphic.Block.__init__(self)
self.trace_count = min(pad_count[0], pad_count[1])
# find x coordinates to be used for vertical bus
self.trace_x = list()
offset = (self.trace_count / 2) * self.TRACE_PITCH
for idx in range(self.trace_count):
self.trace_x.append(center[0] - offset + self.TRACE_PITCH / 2 +
idx * self.TRACE_PITCH)
self.socket_top = Socket(
center + (0, width - width * LOGO_TRACE_RATIO), pad_count[0],
soldermask)
self.socket_bot = Socket(
center - (0, width - width * LOGO_TRACE_RATIO), pad_count[1],
soldermask)
if self.trace_count == 0:
return
# draw traces
for idx in range(self.trace_count):
vectors = list()
idx_inv = self.trace_count - 1 - idx
conn1 = self.socket_top.pad_connector(1, idx)
conn2 = self.socket_bot.pad_connector(
0, idx + pad_count[1] - self.trace_count)
# initial connector
vectors.append(conn1)
# draw to angle
v = conn1 + (idx * self.TRACE_PITCH + self.TRACE_PITCH, 0)
vectors.append(v)
# draw to top 1/3
v = numeric.Vector(
(v[0], center[1] + width / 2 - idx * self.TRACE_PITCH))
vectors.append(v)
# draw to middle
v = numeric.Vector((self.trace_x[idx], v[1]))
vectors.append(v)
# draw to bot 1/3
v = numeric.Vector((v[0],
center[1] - width/2 - idx * self.TRACE_PITCH + \
(self.trace_count - 1) * self.TRACE_PITCH))
vectors.append(v)
# draw to angle
v = numeric.Vector(
(conn2[0] - (idx_inv * self.TRACE_PITCH + self.TRACE_PITCH),
v[1]))
vectors.append(v)
# draw to y-coord of conn2
v = numeric.Vector((v[0], conn2[1]))
vectors.append(v)
# draw to conn2
vectors.append(conn2)
self += trace(vectors, TRACE_WIDTH, TRACE_CLEARANCE)
# draw top ground traces
for idx in range(pad_count[0]):
vectors = list()
conn1 = self.socket_top.pad_connector(0, idx)
# initial connector
vectors.append(conn1)
# draw out
v = conn1 - (self.TRACE_PITCH, 0)
vectors.append(v)
# draw to middle
v = numeric.Vector((v[0], self.socket_top.center[1]))
vectors.append(v)
# draw to logo
v = numeric.Vector(
(center[0] - width / 2 + width * LOGO_TRACE_RATIO, v[1]))
vectors.append(v)
self += trace(vectors, TRACE_WIDTH, 0)
# draw bottom ground traces
for idx in range(pad_count[1]):
vectors = list()
conn1 = self.socket_bot.pad_connector(1, idx)
# initial connector
vectors.append(conn1)
# draw out
v = conn1 + (self.TRACE_PITCH, 0)
vectors.append(v)
# draw to middle
v = numeric.Vector((v[0], self.socket_bot.center[1]))
vectors.append(v)
# draw to logo
v = numeric.Vector(
(center[0] + width / 2 - width * LOGO_TRACE_RATIO, v[1]))
vectors.append(v)
self += trace(vectors, TRACE_WIDTH, 0)
self += self.socket_top
self += self.socket_bot
def pad_connector(self, side, index):
offset = self.PADSPEC[0] / 2
if side == 0: offset *= -1
return numeric.Vector((self.pad_x[side] + offset, self.pad_y[index]))
format='%(levelname)-9s | %(message)s') env.init(COORD_FORMAT, UNIT) layer1 = layer.CopperLayer(1, project_id=PROJECT_ID) layer2 = layer.CopperLayer(2, project_id=PROJECT_ID) soldermask1 = layer.Soldermask(gbrtypes.Side.TOP, 1, project_id=PROJECT_ID) soldermask2 = layer.Soldermask(gbrtypes.Side.BOT, 2, project_id=PROJECT_ID) outline = layer.OutlineLayer(project_id=PROJECT_ID) # draw outline vectors = list() v = numeric.Vector((TRACE_WIDTH / 2, TRACE_WIDTH / 2)) vectors.append(v) v = numeric.Vector((BOARD_SIZE_X - TRACE_WIDTH / 2, v[1])) vectors.append(v) v = numeric.Vector((v[0], BOARD_SIZE_Y - TRACE_WIDTH / 2)) vectors.append(v) v = numeric.Vector((TRACE_WIDTH / 2, v[1])) vectors.append(v) v = numeric.Vector((TRACE_WIDTH / 2, TRACE_WIDTH / 2)) vectors.append(v) t = trace(vectors, TRACE_WIDTH, 0)