Select Git revision
Sam Calisch authored
pcb.py 34.10 KiB
import operator
from math import cos, sin, atan2, radians, degrees, sqrt
import koko.lib.shapes2d as s2d
from koko.lib.text import text
from numpy import *
class PCB(object):
def __init__(self, x0, y0, width, height, chamfer_distance=0):
self.x0 = x0
self.y0 = y0
self.width = width
self.height = height
self.components = []
self.connections = []
self._cutout = None
self.custom_cutout = None
self.custom_layers = {}
self.chamfer_distance = chamfer_distance
@property
def traces(self):
L = [c.pads for c in self.components if c.side == 0] + [c.traces[0] for c in self.connections]
if L:
t = reduce(operator.add, L)
#L = [c.holes for c in self.components if c.holes is not None]
#L.extend([c.holes for c in self.connections if c.holes is not None])
#if L:
# t = t - reduce(operator.add,L)
return t
else: return None
@property
def traces_other_side(self):
L = [c.pads for c in self.components if c.side == 1] + [c.traces[1] for c in self.connections if c.traces[1] is not None]
if L:
t = reduce(operator.add, L)
#L = [c.holes for c in self.components if c.holes is not None]
#L.extend([c.holes for c in self.connections if c.holes is not None])
#if L:
# t = t - reduce(operator.add,L)
return t
else: return None
@property
def holes(self):
L = [c.holes for c in self.components if c.holes is not None]
L.extend([c.holes for c in self.connections if c.holes is not None])
if L:
t = reduce(operator.add,L)
return t
else:
return None
@property
def part_labels_top(self):
L = [c.label for c in self.components if c.label is not None and c.side==0]
return reduce(operator.add, L) if L else None
@property
def part_labels_bot(self):
L = [c.label for c in self.components if c.label is not None and c.side==1]
return reduce(operator.add, L) if L else None
@property
def part_shadows_top(self):
L = [c.shadow_shape for c in self.components if c.shadow_shape is not None and c.side==0]
return reduce(operator.add, L) if L else None
@property
def part_shadows_bot(self):
L = [c.shadow_shape for c in self.components if c.shadow_shape is not None and c.side==1]
return reduce(operator.add, L) if L else None
@property
def pin_labels_top(self):
L = [c.pin_labels for c in self.components if c.pin_labels is not None and c.side==0]
return reduce(operator.add, L) if L else None
@property
def pin_labels_bot(self):
L = [c.pin_labels for c in self.components if c.pin_labels is not None and c.side==1]
return reduce(operator.add, L) if L else None
@property
def cutout(self):
if self.custom_cutout is not None:
if self.holes:
return self.custom_cutout - self.holes
else:
return self.custom_cutout
outer = s2d.rectangle(self.x0, self.x0 + self.width,
self.y0, self.y0 + self.height)
if self.chamfer_distance:
c = self.chamfer_distance
c1 = s2d.triangle(self.x0,self.y0,self.x0,self.y0+c,self.x0+c,self.y0)
c2 = s2d.triangle(self.x0+self.width,self.y0+self.height, self.x0+self.width, self.y0+self.height-c, self.x0+self.width-c, self.y0+self.height)
c3 = s2d.triangle(self.x0,self.y0+self.height, self.x0+c, self.y0+self.height, self.x0, self.y0+self.height-c)
c4 = s2d.triangle(self.x0+self.width,self.y0, self.x0+self.width-c, self.y0, self.x0+self.width, self.y0+c)
outer -= c1+c2+c3+c4
#L = [c.holes for c in self.components if c.holes is not None]
#L.extend([c.holes for c in self.connections if c.holes is not None])
return outer - self.holes if self.holes else outer
#@property
def layout(self,sides=[0,1]):
T = []
if 0 in sides:
if self.part_labels_top:
T.append(s2d.color(self.part_labels_top, (125, 200, 60)))
if self.pin_labels_top:
T.append(s2d.color(self.pin_labels_top, (255, 90, 60)))
if self.traces:
T.append(s2d.color(self.traces-self.holes, (125, 90, 60)))
if self.part_shadows_top:
T.append(s2d.color(self.part_shadows_top-self.holes,(55,55,60)))
if 1 in sides:
if self.part_labels_bot:
T.append(s2d.color(self.part_labels_bot, (90, 60, 255)))
if self.pin_labels_bot:
T.append(s2d.color(self.pin_labels_bot, (175, 30, 175)))
if self.traces_other_side:
T.append(s2d.color(self.traces_other_side-self.holes, (90, 60, 125)))
if self.part_shadows_bot:
T.append(s2d.color(self.part_shadows_bot-self.holes,(45, 30, 62)))
for v in sorted(self.custom_layers.values(),key=lambda v: -v['position']):
if v['visible']: T.append(s2d.color(v['layer'],v['color']))
T.append(s2d.color(self.cutout, (35,35,40)))
return T
def __iadd__(self, rhs):
if isinstance(rhs, Component):
self.components.append(rhs)
elif isinstance(rhs, Connection):
self.connections.append(rhs)
else:
raise TypeError("Invalid type for PCB addition (%s)" % type(rhs))
return self
def add_custom_layer(self,name,layer,color):
self.custom_layers[name] = {'layer':layer,'color':color,'position':len(self.custom_layers),'visible':1}
def hide_layer(self,name):
self.custom_layers[name]['visible'] = 0
def connectH(self, *args, **kwargs):
''' Connects a set of pins or points, traveling first
horizontally then vertically
'''
width = kwargs['width'] if 'width' in kwargs else 0.016
mode = kwargs['mode'] if 'mode' in kwargs else 'explicit'
sides = kwargs['sides'] if 'sides' in kwargs else [0 for a in args[:-1]]
new_sides = []
points = []
args = list(args)
for i,p in enumerate(args):
if not isinstance(p,BoundPin):
if mode=='diff':
args[i] = Point(args[i-1].x+p[0],args[i-1].y+p[1])
elif mode=='explicit':
args[i] = Point(*p)
else:
raise NotImplementedError("Unknown mode type %s"%mode)
for A, B, s in zip(args[:-1], args[1:], sides):
points.append(A); new_sides.append(s)
if (A.x != B.x):
points.append(Point(B.x, A.y)); new_sides.append(s)
if A.y != B.y: points.append(B)
c = Connection(width, *points, sides=new_sides)
self.connections.append(c)
return c
def connectV(self, *args, **kwargs):
''' Connects a set of pins or points, travelling first
vertically then horizontally.
'''
width = kwargs['width'] if 'width' in kwargs else 0.016
mode = kwargs['mode'] if 'mode' in kwargs else 'explicit'
sides = kwargs['sides'] if 'sides' in kwargs else [0 for a in args[:-1]]
new_sides = []
points = []
args = list(args)
for i,p in enumerate(args):
if not isinstance(p,BoundPin):
if mode=='diff':
args[i] = Point(args[i-1].x+p[0],args[i-1].y+p[1])
elif mode=='explicit':
args[i] = Point(*p)
else:
raise NotImplementedError("Unknown mode type %s"%mode)
for A, B, s in zip(args[:-1], args[1:], sides):
points.append(A); new_sides.append(s)
if (A.y != B.y):
points.append(Point(A.x, B.y)); new_sides.append(s)
if A.x != B.x: points.append(B)
c = Connection(width, *points, sides=new_sides)
self.connections.append(c)
return c
def connectD(self, *args, **kwargs):
''' Connects a set of pins or points, travelling first
diagonally then horizontally or vertically, depending on geometry.
'''
width = kwargs['width'] if 'width' in kwargs else 0.016
sides = kwargs['sides'] if 'sides' in kwargs else [0 for a in args[:-1]]
new_sides = []
points = []
def sgn(x):
if x>=0:
return 1
else:
return -1
args = list(args)
for i,p in enumerate(args):
if not isinstance(p,BoundPin):
args[i] = Point(*p)
for A, B, s in zip(args[:-1], args[1:], sides):
points.append(A); new_sides.append(s)
if (B.y-A.y != B.x-A.x):
if abs(B.y-A.y) > abs(B.x-A.x):
points.append(Point(B.x, A.y+sgn(B.y-A.y)*abs(B.x-A.x))); new_sides.append(s)
else:
points.append(Point(A.x+sgn(B.x-A.x)*abs(B.y-A.y),B.y)); new_sides.append(s)
if (A.x != B.x) or (A.y != B.y): points.append(B)
c = Connection(width, *points, sides=new_sides)
self.connections.append(c)
return c
################################################################################
class Component(object):
''' Generic PCB component.
'''
def __init__(self, x, y, rot=0, name='',label_size=0.05, side=0):
''' Constructs a Component object
x X position
y Y position
rotation angle (degrees)
name String
side which side of board 0 for top, 1 for bottom
'''
self.x = x
self.y = y
self.rot = rot
self.name = name
self.label_size = label_size
self.side = side
if self.side == 1:
self.pins = [p.mirror_x() for p in self.pins]
self.vias = [v.mirror_x() for v in self.vias]
def __getitem__(self, i):
if isinstance(i, str):
try:
pin = [p for p in self.pins if p.name == i][0]
except IndexError:
raise IndexError("No pin with name %s" % i)
elif isinstance(i, int):
try:
pin = self.pins[i-1]
except IndexError:
raise IndexError("Pin %i is not in array" %i)
return BoundPin(pin, self)
@property
def pads(self):
pads = reduce(operator.add, [p.pad for p in self.pins])
return s2d.move(s2d.rotate(pads, self.rot), self.x, self.y)
@property
def holes(self):
if self.vias:
holes = reduce(operator.add,[v.hole for v in self.vias])
return s2d.move(s2d.rotate(holes,self.rot), self.x, self.y)
else: return None
@property
def pin_labels(self):
L = []
for p in self.pins:
p = BoundPin(p, self)
if p.pin.name:
t = s2d.rotate(text(p.pin.name, 0, 0, p.pin.label_size),self.rot+p.pin.label_rot)
L.append(s2d.move(t, p.x, p.y))
return reduce(operator.add, L) if L else None
@property
def label(self):
return text(self.name, self.x, self.y, self.label_size)
@property
def shadow_shape(self):
try:
return s2d.move(s2d.rotate(self.shadow, self.rot),self.x, self.y)
except AttributeError:
return None
################################################################################
class Pin(object):
''' PCB pin, with name, shape, and position
'''
def __init__(self, x, y, shape, name='', label_size=.03, label_rot=0):
self.x = x
self.y = y
self.shape = shape
self.name = name
self.label_size = label_size
self.label_rot = label_rot
@property
def pad(self):
return s2d.move(self.shape, self.x, self.y)
def mirror_x(self):
return Pin( -self.x, self.y, self.shape, self.name, label_size=self.label_size, label_rot=self.label_rot )
################################################################################
class Via(object):
''' PCB via, with shape, and position
'''
def __init__(self, x, y, shape):
self.x = x
self.y = y
self.shape = shape
@property
def hole(self):
return s2d.move(self.shape, self.x, self.y)
def mirror_x(self):
return Via( -self.x, self.y, self.shape )
################################################################################
class BoundPin(object):
''' PCB pin localized to a specific component
(so that it has correct x and y positions)
'''
def __init__(self, pin, component):
self.pin = pin
self.component = component
@property
def x(self):
return (cos(radians(self.component.rot)) * self.pin.x -
sin(radians(self.component.rot)) * self.pin.y +
self.component.x)
@property
def y(self):
return (sin(radians(self.component.rot)) * self.pin.x +
cos(radians(self.component.rot)) * self.pin.y +
self.component.y)
@property
def point(self):
return Point(self.x,self.y)
################################################################################
class Point(object):
''' Object with x and y member variables
'''
def __init__(self, x, y):
self.x = x
self.y = y
def __iter__(self):
return iter([self.x, self.y])
def __add__(self, p):
return Point(self.x+p.x,self.y+p.y)
def __sub__(self, p):
return Point(self.x-p.x,self.y-p.y)
def __rmul__(self,a):
return Point(a*self.x,a*self.y)
def magnitude(self):
return sqrt(self.x*self.x + self.y+self.y)
def normalized(self):
return Point(self.x/self.magnitude(), self.y/self.magnitude())
@property
def point(self):
return self
################################################################################
class Connection(object):
''' Connects two pins via a series of intermediate points
'''
def __init__(self, width, *args, **kwargs):
self.width = width
self.points = [
a if isinstance(a, BoundPin) else Point(*a) for a in args
]
self.sides = kwargs['sides'] if 'sides' in kwargs else [0 for a in args[:-1]] #0 is base side, 1 is other side
self.holes = None
self.jumpers = []
def add_jumper(self,p,rot=0,width=.12, height=.07,thick=.05):
self.jumpers.append((p,rot,width,height,thick))
return self
def cut_corners(self,idx):
for i in idx:
i,v = i #unpack index and distance
assert(i>0) #start corner numbering at 1
assert(i<len(self.points)) #no corner to cut at end
d = lambda p,q: sqrt( (p.x-q.x)**2 + (p.y-q.y)**2 )
dm = d(self.points[i],self.points[i-1])
dp = d(self.points[i],self.points[i+1])
#if dm > dp:
self.points = self.points[:i] + \
[Point(self.points[i].x-v/dm*(self.points[i].x-self.points[i-1].x ), self.points[i].y-v/dm*(self.points[i].y-self.points[i-1].y )),
Point(self.points[i].x+v/dp*(self.points[i+1].x-self.points[i].x ), self.points[i].y+v/dp*(self.points[i+1].y-self.points[i].y ))
] + \
self.points[i+1:]
self.sides.insert(i,self.sides[i])
#else:
# self.points[i] = self.points[i] - dm/dp*(self.points[i]-self.points[i+1])
return self
@property
def traces(self):
#_pad_1206 = s2d.rectangle(-0.025, 0.025, -0.034, 0.034)
_pad_via = s2d.circle(0,0,.025) #s2d.rectangle(-0.025, 0.025, -0.025, 0.025)
_hole_via = s2d.circle(0,0,.016)
jumper_cuts = []
jumper_pads = []
for p,r,w,h,t in self.jumpers:
_jumper_pad = s2d.move(s2d.rectangle(-.5*t, .5*t, -.5*h, .5*h),-.5*w,0)
_jumper_pad += s2d.move(s2d.rectangle(-.5*t, .5*t, -.5*h, .5*h), .5*w,0)
_cut = s2d.rectangle(-.5*w,.5*w,-.5*h,.5*h)
jumper_cuts.append(s2d.move(s2d.rotate(_cut,r),p[0],p[1]))
jumper_pads.append(s2d.move(s2d.rotate(_jumper_pad,r),p[0],p[1]))
t = [[],[]]
for p1, p2, side in zip(self.points[:-1], self.points[1:], self.sides):
d = sqrt((p1.x - p2.x)**2 + (p1.y - p2.y)**2)
if p2 != self.points[-1]:
d += self.width/2
a = atan2(p2.y - p1.y, p2.x - p1.x)
r = s2d.rounded_rectangle(0, d, -self.width/2, self.width/2,1.)
t[side].append(s2d.move(s2d.rotate(r, degrees(a)), p1.x, p1.y))
try:
result0 = reduce(operator.add, t[0])
except TypeError:
result0 = None
try:
result1 = reduce(operator.add, t[1])
except TypeError:
result1 = None
#calculate locations for via holes and pads
for s1,s2,p in zip(self.sides[:-1],self.sides[1:],self.points[1:-1]):
if s1!=s2:
result0 += s2d.move(_pad_via,p.x,p.y)
result1 += s2d.move(_pad_via,p.x,p.y)
self.holes += s2d.move(_hole_via,p.x,p.y)
if len(self.jumpers)!=0:
result0 -= reduce(operator.add,jumper_cuts)
result0 += reduce(operator.add,jumper_pads)
return result0, result1
################################################################################
# Discrete passive components
################################################################################
_pad_1206 = s2d.rectangle(-0.032, 0.032, -0.034, 0.034)
class R_1206(Component):
''' 1206 Resistor
'''
pins = [Pin(-0.06, 0, _pad_1206), Pin(0.06, 0, _pad_1206)]
prefix = 'R'
vias = []
class C_1206(Component):
''' 1206 Capacitor
'''
pins = [Pin(-0.06, 0, _pad_1206), Pin(0.06, 0, _pad_1206)]
prefix = 'C'
vias = []
_pad_0805 = s2d.rectangle(-.023,.023, -.027, .027)
class R_0805(Component):
''' 0805 Resistor
'''
pins = [Pin(-0.04, 0, _pad_0805), Pin(0.04, 0, _pad_0805)]
prefix = 'R'
vias = []
class C_0805(Component):
''' 0805 Capacitor
'''
pins = [Pin(-0.04, 0, _pad_0805), Pin(0.04, 0, _pad_0805)]
prefix = 'C'
vias = []
_pad_SJ = s2d.rectangle(-0.02, 0.02, -0.03, 0.03)
class SJ(Component):
''' Solder jumper
'''
pins = [Pin(-0.029, 0, _pad_SJ), Pin(0.029, 0, _pad_SJ)]
prefix = 'SJ'
vias = []
_pad_SOD_123 = s2d.rectangle(-0.02, 0.02, -0.024, 0.024)
class D_SOD_123(Component):
''' Diode
'''
pins = [Pin(-0.07, 0, _pad_SOD_123, 'A'),
Pin(0.07, 0, _pad_SOD_123, 'C')]
prefix = 'D'
vias = []
################################################################################
# Connectors
################################################################################
_pad_USB_trace = s2d.rectangle(-0.0075, 0.0075, -0.04, 0.04)
_pad_USB_foot = s2d.rectangle(-0.049, 0.049, -0.043, 0.043)
class USB_mini_B(Component):
''' USB mini B connector
Hirose UX60-MB-5ST
'''
pins = [
Pin(0.063, 0.24, _pad_USB_trace, 'G'),
Pin(0.0315, 0.24, _pad_USB_trace),
Pin(0, 0.24, _pad_USB_trace, '+'),
Pin(-0.0315, 0.24, _pad_USB_trace, '-'),
Pin(-0.063, 0.24, _pad_USB_trace, 'V'),
Pin( 0.165, 0.21, _pad_USB_foot),
Pin(-0.165, 0.21, _pad_USB_foot),
Pin( 0.165, 0.0, _pad_USB_foot),
Pin(-0.165, 0.0, _pad_USB_foot)
]
prefix = 'J'
vias = []
_pad_header = s2d.rectangle(-0.06, 0.06, -0.025, 0.025)
_pad_header_skinny = s2d.rectangle(-0.06, 0.06, -0.020, 0.020)
class Header_4(Component):
''' 4-pin header
fci 95278-101a04lf bergstik 2x2x0.1
'''
pins = [
Pin(-0.107, 0.05, _pad_header),
Pin(-0.107, -0.05, _pad_header),
Pin( 0.107, -0.05, _pad_header),
Pin( 0.107, 0.05, _pad_header)
]
prefix = 'J'
vias = []
class Header_4_skinny(Component):
''' 4-pin header
fci 95278-101a04lf bergstik 2x2x0.1
'''
pins = [
Pin(-0.107, 0.05, _pad_header_skinny),
Pin(-0.107, -0.05, _pad_header_skinny),
Pin( 0.107, -0.05, _pad_header_skinny),
Pin( 0.107, 0.05, _pad_header_skinny)
]
prefix = 'J'
vias = []
class Header_Power(Component):
''' 4-pin header
fci 95278-101a04lf bergstik 2x2x0.1
'''
pins = [
Pin(-0.107, 0.05, _pad_header,"V"),
Pin(-0.107, -0.05, _pad_header,"GND"),
Pin( 0.107, -0.05, _pad_header),
Pin( 0.107, 0.05, _pad_header)
]
prefix = 'J'
vias = []
class Header_ISP(Component):
''' ISP programming header
FCI 95278-101A06LF Bergstik 2x3x0.1
'''
pins = [
Pin(-0.107, 0.1, _pad_header, 'GND'),
Pin(-0.107, 0, _pad_header, 'MOSI'),
Pin(-0.107, -0.1, _pad_header, 'V'),
Pin( 0.107, -0.1, _pad_header, 'MISO'),
Pin( 0.107, 0, _pad_header, 'SCK'),
Pin( 0.107, 0.1, _pad_header, 'RST')
]
prefix = 'J'
vias = []
class Header_ISP_skinny(Component):
''' ISP programming header
FCI 95278-101A06LF Bergstik 2x3x0.1
'''
pins = [
Pin(-0.107, 0.1, _pad_header_skinny, 'GND'),
Pin(-0.107, 0, _pad_header_skinny, 'MOSI'),
Pin(-0.107, -0.1, _pad_header_skinny, 'V'),
Pin( 0.107, -0.1, _pad_header_skinny, 'MISO'),
Pin( 0.107, 0, _pad_header_skinny, 'SCK'),
Pin( 0.107, 0.1, _pad_header_skinny, 'RST')
]
prefix = 'J'
vias = []
#shadow = s2d.rectangle(-.06,8/25.4,-.325,.325)
class Header_FTDI(Component):
''' FTDI cable header
'''
pins = [
Pin(0, 0.25, _pad_header, 'GND'),
Pin(0, 0.15, _pad_header, 'CTS'),
Pin(0, 0.05, _pad_header, 'VCC'),
Pin(0, -0.05, _pad_header, 'TX'),
Pin(0, -0.15, _pad_header, 'RX'),
Pin(0, -0.25, _pad_header, 'RTS')
]
prefix = 'J'
vias = []
shadow = s2d.rectangle(-.06,8/25.4,-.325,.325)
class Header_FTDI_skinny(Component):
''' FTDI cable header
'''
pins = [
Pin(0, 0.25, _pad_header_skinny, 'GND'),
Pin(0, 0.15, _pad_header_skinny, 'CTS'),
Pin(0, 0.05, _pad_header_skinny, 'VCC'),
Pin(0, -0.05, _pad_header_skinny, 'TX'),
Pin(0, -0.15, _pad_header_skinny, 'RX'),
Pin(0, -0.25, _pad_header_skinny, 'RTS')
]
prefix = 'J'
vias = []
shadow = s2d.rectangle(-.06,8/25.4,-.325,.325)
class ScrewTerminal(Component):
pitch = .131
_pad = s2d.rectangle(-0.04, 0.04, -0.04, 0.04)
_via = s2d.circle(0,0,.025)
pins = [Pin(-.5*pitch,0,_pad),Pin(.5*pitch,0,_pad)]
vias = [Via(-.5*pitch,0,_via),Via(.5*pitch,0,_via)]
shadow = s2d.rectangle(-3.5/25.4,3.5/25.4,-3/25.4,3/25.4)
class ScrewTerminal3(Component):
pitch = .131
_pad = s2d.rectangle(-0.04, 0.04, -0.04, 0.04)
_via = s2d.circle(0,0,.025)
pins = [Pin(-pitch,0,_pad),Pin(0,0,_pad),Pin(pitch,0,_pad)]
vias = [Via(-pitch,0,_via),Via(0,0,_via),Via(pitch,0,_via)]
shadow = s2d.rectangle(-5.35/25.4,5.35/25.4,-3/25.4,3/25.4)
class JST_2(Component):
pitch = 2./25.4
_pad = s2d.rectangle(-0.5/25.4,0.5/25.4, -1.75/25.4, 1.75/25.4)
_pad2 = s2d.rectangle(-.75/25.4,.75/25.4,-1.7/25.4,1.7/25.4)
y2 = -4.55/25.4
pins = [Pin(-.5*pitch,0,_pad,'VCC'),Pin(.5*pitch,0,_pad,'GND'),Pin(-.5*pitch-2.35/25.4,y2,_pad2),Pin(.5*pitch+2.35/25.4,y2,_pad2)]
vias = []
shadow = s2d.rectangle(-3.95/25.4,3.95/25.4,y2-1.7/25.4,1.75/25.4)
################################################################################
# SOT-23 components
################################################################################
_pad_SOT23 = s2d.rectangle(-.02,.02,-.012,.012)
class NMOS_SOT23(Component):
''' NMOS transistor in SOT23 package
Fairchild NDS355AN
'''
pins = [
Pin(0.045, -0.0375, _pad_SOT23,'G'),
Pin(0.045, 0.0375, _pad_SOT23,'S'),
Pin(-0.045, 0, _pad_SOT23,'D')
]
prefix = 'Q'
vias = []
class PMOS_SOT23(Component):
''' PMOS transistor in SOT23 package
Fairchild NDS356AP
'''
pins = [
Pin(-0.045, -0.0375, _pad_SOT23,'G'),
Pin(-0.045, 0.0375, _pad_SOT23,'S'),
Pin(0.045, 0, _pad_SOT23,'D')
]
prefix = 'Q'
vias = []
class Regulator_SOT23(Component):
''' SOT23 voltage regulator
'''
pins = [
Pin(-0.045, -0.0375, _pad_SOT23,'Out'),
Pin(-0.045, 0.0375, _pad_SOT23,'In'),
Pin(0.045, 0, _pad_SOT23,'GND')
]
prefix = 'U'
vias = []
class Regulator_LM3480(Component):
''' SOT23 voltage regulator, LM3480
'''
pins = [
Pin(-0.045, -0.0375, _pad_SOT23,'In'),
Pin(-0.045, 0.0375, _pad_SOT23,'Out'),
Pin(0.045, 0, _pad_SOT23,'GND')
]
prefix = 'U'
vias = []
###########
# H Bridge
############
_pad_SOIC = s2d.rectangle(-.041,.041,-.015,.015)
class A4953_SOICN(Component):
pins = [
Pin(-.11, .075,_pad_SOIC+s2d.circle(-.041,0,.015),"GND"),
Pin(-.11, .025,_pad_SOIC,"IN2"),
Pin(-.11,-.025,_pad_SOIC,"IN1"),
Pin(-.11,-.075,_pad_SOIC,"VREF"),
Pin( .11,-.075,_pad_SOIC,"VBB"),
Pin( .11,-.025,_pad_SOIC,"OUT1"),
Pin( .11, .025,_pad_SOIC,"LSS"),
Pin( .11, .075,_pad_SOIC,"OUT2"),
Pin( 0,0,s2d.rectangle(-.04,.04,-.075,.075),"")
]
prefix = 'U'
vias = []
################################################################################
# Clock crystals
################################################################################
_pad_XTAL_NX5032GA = s2d.rectangle(-.039,.039,-.047,.047)
class XTAL_NX5032GA(Component):
pins = [Pin(-0.079, 0, _pad_XTAL_NX5032GA),
Pin(0.079, 0, _pad_XTAL_NX5032GA)]
prefix = 'X'
vias = []
################################################################################
# Atmel microcontrollers
################################################################################
_pad_SOIC = s2d.rectangle(-0.041, 0.041, -0.015, 0.015)
class ATtiny45_SOIC(Component):
pins = []
y = 0.075
for t in ['NC', 'PB3', 'PB4', 'GND']:
pins.append(Pin(-0.14, y, _pad_SOIC, t))
y -= 0.05
for p in ['PB0', 'PB1', 'PB2', 'VCC']:
y += 0.05
pins.append(Pin(0.14, y, _pad_SOIC, p))
del y
prefix = 'U'
vias = []
class ATtiny44_SOIC(Component):
pins = []
y = 0.15
for t in ['VCC', 'PB0', 'PB1', 'PB3', 'PB2', 'PA7', 'PA6']:
pad = _pad_SOIC + s2d.circle(-0.041, 0, 0.015) if t == 'VCC' else _pad_SOIC
pins.append(Pin(-0.12, y, pad, t))
y -= 0.05
for t in ['PA5', 'PA4', 'PA3', 'PA2', 'PA1', 'PA0', 'GND']:
y += 0.05
pins.append(Pin(0.12, y, _pad_SOIC, t))
prefix = 'U'
vias = []
_pad_TQFP_h = s2d.rectangle(-0.025, 0.025, -0.008, 0.008)
_pad_TQFP_v = s2d.rectangle(-0.008, 0.008, -0.025, 0.025)
class ATmega88_TQFP(Component):
pins = []
y = 0.1085
for t in ['PD3', 'PD4', 'GND', 'VCC', 'GND', 'VCC', 'PB6', 'PB7']:
pins.append(Pin(-0.18, y, _pad_TQFP_h, t))
y -= 0.031
x = -0.1085
for t in ['PD5', 'PD6', 'PD7', 'PB0', 'PB1', 'PB2', 'PB3', 'PB4']:
pins.append(Pin(x, -0.18, _pad_TQFP_v, t))
x += 0.031
y = -0.1085
for t in ['PB5', 'AVCC', 'ADC6', 'AREF', 'GND', 'ADC7', 'PC0', 'PC1']:
pins.append(Pin(0.18, y, _pad_TQFP_h, t))
y += 0.031
x = 0.1085
for t in ['PC2', 'PC3', 'PC4', 'PC5', 'PC6', 'PD0', 'PD1', 'PD2']:
pins.append(Pin(x, 0.18, _pad_TQFP_v, t))
x -= 0.031
del x, y
prefix = 'U'
vias = []
################################################################################
# CBA logo
################################################################################
_pin_circle_CBA = s2d.circle(0, 0, 0.02)
_pin_square_CBA = s2d.rectangle(-0.02, 0.02, -0.02, 0.02)
class CBA(Component):
pins = []
for i in range(3):
for j in range(3):
pin = _pin_circle_CBA if i == 2-j and j >= 1 else _pin_square_CBA
pins.append(Pin(0.06*(i-1), 0.06*(j-1), pin))
vias = []
class ESP8266_03(Component):
_pad = s2d.rectangle(-0.04, 0.04, -0.03, 0.03)
_via = s2d.circle(0,0,.019)
names = ['VCC','GPIO14','GPIO12','GPIO13','GPIO15','GPIO2','GPIO0',
'WIFI_ANT','CH-PD','GPIO18','URXD','UTXD','NC','GND']
w = 12.2/25.4
l = 17.4/25.4
wp = 12.2/25.4
lp = .5
dp = 2/25.4
ys = arange(.5*lp-dp ,-.5*lp-.001-dp,-dp)
pts = vstack(( dstack((-.5*wp*ones_like(ys),ys))[0], dstack((.5*wp*ones_like(ys),ys))[0] ))
pins = [Pin(p[0],p[1],_pad,n) for n,p in zip(names,pts)]
vias = []#[Via(p[0],p[1],_via) for n,p in zip(names,pts)]
shadow = s2d.rectangle(-.5*w,.5*w,-.5*l,.5*l)
prefix = 'IC'
class ZLDO1117(Component):
'''3.3 V 1 A regulator, SOT223'''
_pad1 = s2d.rectangle(-.6/25.4,.6/25.4,-.8/25.4,.8/25.4)
_pad2 = s2d.rectangle(-1.65/25.4,1.65/25.4,-.6/25.4,.6/25.4)
pins = [
Pin(-2.3/25.4, -3.2/25.4, _pad1,'GND'),
Pin(0, -3.2/25.4, _pad1,'Vout'),
Pin(2.3/25.4, -3.2/25.4, _pad1,'Vin'),
Pin(0, 3.2/25.4, _pad2,'Vout2'),
]
prefix = 'U'
vias = []
class AstarMicro(Component):
''' Polulo Astar micro
'''
_pad = s2d.rectangle(-0.04, 0.04, -0.025, 0.025)
_via = s2d.circle(0,0,.019)
#flip names since through hole
names = [
'VIN','GND','5V','3v3','RST','12/A11/PWM','11','10/A10/PWM','A1','A0',
'9/A9/PWM','8/A8','7','6/A7/PWM','5/PWM','4/A6','3/PWM','2','1','0']
w = .6
l = 1.
wp = .5
lp = .9
ys = arange(.5*lp,-.5*lp-.001,-.1)
os = 0*.13*(arange(shape(ys)[0])%2-.5)
pts = vstack(( dstack((-.5*wp*ones_like(ys)+os,ys[::-1]))[0], dstack((.5*wp*ones_like(ys)-os,ys))[0] ))
pins = [Pin(p[0],p[1],_pad,n) for n,p in zip(names,pts)]
vias = [Via(p[0],p[1],_via) for n,p in zip(names,pts)]
shadow = s2d.rectangle(-.5*w,.5*w,-.5*l,.5*l)
prefix = 'IC'
class Header_bldc_skinny(Component):
''' brushless motor logic
'''
_pad_header_skinny = s2d.rectangle(-0.06, 0.06, -0.020, 0.020)
pins = [
Pin(0, 0.1, _pad_header_skinny, 'GND'),
Pin(0, -0.0, _pad_header_skinny, 'VCC'),
Pin(0, -0.1, _pad_header_skinny, 'RC')
]
prefix = 'J'
shadow = s2d.rectangle(-.06,8/25.4,-.325,.325)
vias = []
class A4988_Carrier(Component):
''' Stepper driver carrier black from pololu
'''
_pad = s2d.rectangle(-0.04, 0.04, -0.028, 0.028)
_via = s2d.circle(0,0,.019)
names = ['VMOT','GMOT','2B','2A','1A','1B','VDD','GND','DIR','STEP','SLP','RST','MS3','MS2','MS1','EN']
ys = arange(.4,-.4+.001,-.1)-.05
pts = vstack(( dstack((-.25*ones_like(ys),ys))[0], dstack((.25*ones_like(ys),ys[::-1]))[0] ))
pins = [Pin(p[0],p[1],_pad,n) for n,p in zip(names,pts)]
vias = [Via(p[0],p[1],_via) for n,p in zip(names,pts)]
prefix = 'IC'
shadow = s2d.rectangle(-.3,.3,-.45,.45)
class CDRH2D18(Component):
'''Power Inductor'''
def chamfered_rectangle(x0,x1,y0,y1,c):
r = s2d.rectangle(x0,x1,y0,y1)
c1 = s2d.triangle(x0,y0,x0,y0+c,x0+c,y0)
c2 = s2d.triangle(x1,y1, x1, y1-c, x1-c, y1)
c3 = s2d.triangle(x0,y1, x0+c, y1, x0, y1-c)
c4 = s2d.triangle(x1,y0, x1-c, y0, x1, y0+c)
return r-c1-c2-c3-c4
_pad = s2d.rectangle(-.65/25.4,.65/25.4,-.65/25.4,.65/25.4)
pins = [Pin(-1.5/25.5,0,_pad), Pin(1.5/25.5,0,_pad)]
vias = []
shadow = s2d.rotate(chamfered_rectangle(-1.5/25.4,1.5/25.4,-1.5/25.4, 1.5/25.4,1/25.5),45)
prefix='I'
class LTC35881(Component):
''' Energy Scavenger '''
_pad = s2d.rectangle(-.889/2/25.4, .889/2/25.4,-.25/2/25.4, .25/2/25.4)
p = .5/25.4
pins = [
Pin(0, 0, s2d.rectangle(-1.68/2/25.4,1.68/2/25.4,-1.88/2/25.4,1.88/2/25.4), 'GND'),
Pin(-2.1/25.4, 2*p,_pad,'PZ1',label_size=.015,label_rot=0),
Pin(-2.1/25.4, 1*p,_pad,'PZ2',label_size=.015,label_rot=0),
Pin(-2.1/25.4, 0,_pad,'CAP',label_size=.015,label_rot=0),
Pin(-2.1/25.4,-1*p,_pad,'VIN',label_size=.015,label_rot=0),
Pin(-2.1/25.4,-2*p,_pad,'SW',label_size=.015,label_rot=0),
Pin(2.1/25.4, -2*p,_pad,'VOUT',label_size=.015,label_rot=0),
Pin(2.1/25.4, -1*p,_pad,'VIN2',label_size=.015,label_rot=0),
Pin(2.1/25.4, 0,_pad,'D1',label_size=.015,label_rot=0),
Pin(2.1/25.4, 1*p,_pad,'D0',label_size=.015,label_rot=0),
Pin(2.1/25.4, 2*p,_pad,'PGOOD',label_size=.015,label_rot=0)
]
prefix = 'J'
h = 2.9/25.4; w = 2.8/25.4;
shadow = s2d.rectangle(-.5*w,.5*w,-.5*h,.5*h)
vias = []
class DSK414(Component):
'''Dynacap, ELNA, 220mF'''
pins = [
Pin(0,5.15/25.4, s2d.rectangle(-2.4/25.4,2.4/25.4,-1./25.4,1/25.4),'+'),
Pin(0,-5/25.4, s2d.rectangle(-2/25.4,2/25.4,-.85/25.4,.81/25.4),'-')
]
vias = []
shadow = s2d.rectangle(-2.5/25.4,2.5/25.4,-5.85/25.4, 6.15/25.4)
shadow += s2d.circle(0,0,3.4/25.4)
prefix='C'
class EECRG(Component):
'''Panasonic 1F, 3.6 V'''
_pad = s2d.rectangle(-.02,.02,-.035,.035)
pins = [
Pin(-10/25.4, 0, _pad),
Pin(10/25.4, 0, _pad)
]
_via = s2d.rectangle(-.1/25.4,.1/25.4,-.5/25.4,.5/25.4)
vias = [Via(p.x,p.y,_via) for p in pins]
shadow = s2d.rectangle(0,0,0,0)
prefix='C'
class EEE1EA101XP(Component):
'''Panasonic 100uF, 25V'''
_pad = s2d.rectangle(-.6/25.4,.6/25.4,-1.35/25.4,1.35/25.4)
pins = [
Pin(0, 2.2/25.4, _pad),
Pin(0, -2.2/25.4, _pad)
]
#_via = s2d.rectangle(-.1/25.4,.1/25.4,-.5/25.4,.5/25.4)
vias = []
def half_chamfered_rectangle(x0,x1,y0,y1,c):
r = s2d.rectangle(x0,x1,y0,y1)
c1 = s2d.triangle(x0,y0,x0,y0+c,x0+c,y0)
c2 = s2d.triangle(x1,y1, x1, y1-c, x1-c, y1)
c3 = s2d.triangle(x0,y1, x0+c, y1, x0, y1-c)
c4 = s2d.triangle(x1,y0, x1-c, y0, x1, y0+c)
return r-c1-c4
shadow = half_chamfered_rectangle(-3.3/25.4,3.3/25.4,-3.3/25.4,3.3/25.4,1/25.4)
prefix='C'
def chamfered_rectangle(x0,x1,y0,y1,c):
r = s2d.rectangle(x0,x1,y0,y1)
c1 = s2d.triangle(x0,y0,x0,y0+c,x0+c,y0)
c2 = s2d.triangle(x1,y1, x1, y1-c, x1-c, y1)
c3 = s2d.triangle(x0,y1, x0+c, y1, x0, y1-c)
c4 = s2d.triangle(x1,y0, x1-c, y0, x1, y0+c)
return r-c1-c2-c3-c4