diff --git a/kokopelli/.gitkeep b/kokopelli/.gitkeep
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/kokopelli/README.md b/kokopelli/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..2e9e9ddb8b61e0b7dc5d1212a648199a5449ab44
--- /dev/null
+++ b/kokopelli/README.md
@@ -0,0 +1,10 @@
+<a href='https://www.mattkeeter.com/projects/kokopelli/'>Kokopelli</a> is an old (but great) project from <a href='https://www.mattkeeter.com/'>Matt Keeter</a>. Its a full-blown CAD program, but it can be used for designing PCBs. The programmatic interface makes it easy to set up relationships between components, traces, etc. and you can toolpath for the circuit mill right in kokopelli.
+
+To use it, clone it from github: https://github.com/mkeeter/kokopelli and install with the makefile.
+
+I've added a couple small utilities to Matt's original PCB design library. If you'd like to use them, you can replace the existing koko/lib/pcb.py with <a href='pcb.py'>pcb.py</a> and reinstall.
+
+A fun example using several of the included features is a stepper driver board I designed:
+
+<img src='servo-stepper-v1-layout.png' width=500px>
+
diff --git a/kokopelli/pcb.py b/kokopelli/pcb.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d4b139020a0391e45f453c64ad91a4624b4140b
--- /dev/null
+++ b/kokopelli/pcb.py
@@ -0,0 +1,988 @@
+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
+
diff --git a/kokopelli/servo-stepper-v1-layout.png b/kokopelli/servo-stepper-v1-layout.png
new file mode 100644
index 0000000000000000000000000000000000000000..3f137754d7cc072de17008228bd37f4aa9c34d89
Binary files /dev/null and b/kokopelli/servo-stepper-v1-layout.png differ