pcb.py

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