Пример #1
0
    kicad_mod.addPad('""', 'smd', 'rect', {'x':mpad_x, 'y':mpad_y}, {'x':mpad_w, 'y':mpad_h}, 0, ['F.Cu', 'F.Paste', 'F.Mask'])
    kicad_mod.addPad('""', 'smd', 'rect', {'x':-mpad_x, 'y':mpad_y}, {'x':mpad_w, 'y':mpad_h}, 0, ['F.Cu', 'F.Paste', 'F.Mask'])

    
    A = (pincount - 1) * pitch
    B = A + 2.9 + 1.5
    
    x1 = -B/2
    y1 = 0
    x2 = B / 2
    y2 = 3.5
    
    #draw the connector outline on the F.Fab layer
    kicad_mod.addRectLine(
        {'x': x1,'y': y1},
        {'x': x2,'y': y2},
        'F.Fab', 0.15
    )
    
    #line offset 
    off = 0.15
    
    x1 -= off
    y1 -= off
    
    x2 += off
    y2 += off
    
    q = 0.75
    
    #draw the top line
kicad_mod.addText('reference', 'REF**', {
    'x': start_pos_x - 3,
    'y': -7
}, 'F.SilkS')
kicad_mod.addText('value', footprint_name, {
    'x': end_pos_x / 2.,
    'y': 5
}, 'F.Fab')

# create Silkscreen

# outline
kicad_mod.addRectLine({
    'x': start_pos_x - 3.87 - 1.2,
    'y': 3.2
}, {
    'x': end_pos_x + 3.87 + 1.2,
    'y': -pad_spacing - 3.2
}, 'F.SilkS', 0.15)

# slot(s)
if pincount < 60:
    kicad_mod.addPolygoneLine([{
        'x': ((start_pos_x + end_pos_x) / 2) - 4.45 / 2,
        'y': 3.2
    }, {
        'x': ((start_pos_x + end_pos_x) / 2) - 4.45 / 2,
        'y': 1.9
    }, {
        'x': start_pos_x - 3.87,
        'y': 1.9
    kicad_mod.addPolygoneLine([{'x':x1,'y':y1},
                               {'x':x1-0.5,'y':y1-0.25},
                               {'x':x1-0.5,'y':y1+0.25},
                               {'x':x1,'y':y1}])
                              
    #add courtyard
    
    #courtyard corners
    cx1 = -B/2 - 0.5
    cx2 =  B/2 + 0.5
    
    cy1 = -5.8
    cy2 = 0.6
    
    #make sure they lie on an 0.05mm grid
    
    cx1 = int(cx1/0.05) * 0.05
    cx2 = int(cx2/0.05) * 0.05
    
    cy1 = int(cy1/0.05) * 0.05 - 0.0625
    cy2 = int(cy2/0.05) * 0.05 + 0.0375
    
    kicad_mod.addRectLine({'x':cx1,'y':cy1},{'x':cx2,'y':cy2},'F.CrtYd',0.05)

    f = open(footprint_name + ".kicad_mod","w")

    f.write(kicad_mod.__str__())

    f.close()
        'y': 1.8
    }, 'F.SilkS', 0.15)

kicad_mod.addCircle({
    'x': start_pos_x - 2.95 + 0.8 + 0.75,
    'y': 3.1 + 0.75
}, {
    'x': 0.25,
    'y': 0
}, 'F.SilkS', 0.15)

# create Courtyard
kicad_mod.addRectLine(
    {
        'x': start_pos_x - 1.6 - 1.6 - 0.5,
        'y': 5.6 + 0.275 + 0.25
    }, {
        'x': end_pos_x + 1.6 + 1.6 + 0.5,
        'y': -1.9 - 0.275 - 0.25
    }, 'F.CrtYd', 0.05)

# create pads
createNumberedPadsSMD(kicad_mod, pincount, 2, {
    'x': 1,
    'y': 5.5
}, 4.75 - 1.9)  #TODO y
kicad_mod.addPad('""', 'smd', 'rect', {
    'x': start_pos_x - 1.6 - 1.6 / 2,
    'y': 0.6
}, {
    'x': 1.6,
    'y': 3
Пример #5
0
                          ,'F.SilkS', 0.15)

kicad_mod.addLine({'x':start_pos_x-2.95+0.8, 'y':1}, {'x':start_pos_x-2.95, 'y':1}, 'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':end_pos_x+0.9, 'y':1}
                          ,{'x':end_pos_x+2.95-0.8, 'y':1}
                          ,{'x':end_pos_x+2.95-0.8, 'y':-0.6}
                          ,{'x':end_pos_x+2.95, 'y':-0.6}
                          ,{'x':end_pos_x+2.95, 'y':3.5}]
                          ,'F.SilkS', 0.15)

kicad_mod.addLine({'x':end_pos_x+2.95-0.8, 'y':1}, {'x':end_pos_x+2.95, 'y':1}, 'F.SilkS', 0.15)

kicad_mod.addLine({'x':start_pos_x-1.2, 'y':7}, {'x':end_pos_x+1.2, 'y':7}, 'F.SilkS', 0.15)

kicad_mod.addRectLine({'x':start_pos_x-1.2, 'y':2.1}, {'x':start_pos_x-0.2, 'y':5.5}, 'F.SilkS', 0.15)
kicad_mod.addRectLine({'x':end_pos_x+1.2, 'y':2.1}, {'x':end_pos_x+0.2, 'y':5.5}, 'F.SilkS', 0.15)

for i in range(0, pincount-1):
    middle_x = start_pos_x+1+i*2
    start_x = middle_x-0.1
    end_x = middle_x+0.1
    kicad_mod.addLine({'x':start_x, 'y':1}, {'x':end_x, 'y':1}, 'F.SilkS', 0.15)

kicad_mod.addCircle({'x':start_pos_x-2.95+0.8+0.75, 'y':0.25}, {'x':0.25, 'y':0}, 'F.SilkS', 0.15)

# create Courtyard
kicad_mod.addRectLine({'x':start_pos_x-1.6-1.6-0.5, 'y':7.25+0.275+0.25}, {'x':end_pos_x+1.6+1.6+0.5, 'y':-1.75-0.275-0.25}, 'F.CrtYd', 0.05)

# create pads
createNumberedPadsSMD(kicad_mod, pincount, 2, {'x':1, 'y':3.5}, 0)
    kicad_mod.setCenterPos({"x": 0, "y": ymid})

    # set general values
    kicad_mod.addText("reference", "REF**", {"x": 0, "y": -8.5 - 0.675}, "F.SilkS")
    kicad_mod.addText("value", footprint_name, {"x": 0, "y": 2}, "F.Fab")

    # outline
    x1 = -B / 2
    x2 = B / 2

    y2 = -0.4
    y1 = y2 - 5.8

    # add outline to F.Fab
    kicad_mod.addRectLine({"x": x1, "y": y1}, {"x": x2, "y": y2}, "F.Fab", 0.15)

    # expand the outline a little bit
    out = 0.2
    x1 -= out
    x2 += out
    y1 -= out
    y2 += out

    # pad size
    pw = 0.9
    ph = 2.5

    # create dem pads
    createNumberedPadsSMD(kicad_mod, pincount, -pitch, {"x": pw, "y": ph}, py)
    A = (pincount - 1) * 1.5
    B = A + 4.5

    #outline
    x1 = -1.55 - 0.7
    x2 = x1 + B

    xMid = x1 + B/2

    y2 = 3.7 + 3.65
    y1 = y2 - 7.8 - 0.2
    
    #add outline to F.Fab
    kicad_mod.addRectLine(
        {'x': x1, 'y': y1},
        {'x': x2, 'y': y2},
        'F.Fab', 0.15
        )

    #expand the outline a little bit
    out = 0.15
    x1 -= out
    x2 += out
    y1 -= out
    y2 += out

    # set general values
    kicad_mod.addText('reference', 'REF**', {'x':xMid, 'y':-2}, 'F.SilkS')
    kicad_mod.addText('value', footprint_name, {'x':xMid, 'y':9}, 'F.Fab')

    dia = 1.35
    kicad_mod.addText("value", footprint_name, {"x": A / 2, "y": 3.5}, "F.Fab")

    drill = 0.9

    dia = 1.85

    # create pads
    createNumberedPadsTHT(kicad_mod, pincount, pitch, drill, {"x": dia, "y": dia})

    x1 = -2.5
    y1 = -1.6
    x2 = x1 + B
    y2 = y1 + 3.8

    # draw the main outline on F.Fab layer
    kicad_mod.addRectLine({"x": x1, "y": y1}, {"x": x2, "y": y2}, "F.Fab", 0.15)

    # line offset
    off = 0.15

    x1 -= off
    y1 -= off

    x2 += off
    y2 += off

    # draw the main outline around the footprint
    kicad_mod.addRectLine({"x": x1, "y": y1}, {"x": x2, "y": y2})

    T = 0.5
                          ,{'x':end_pos_x-0.5, 'y':-1.2}
                          ,{'x':end_pos_x+1.2, 'y':-1.2} # +1.45
                          ,{'x':end_pos_x+1.2, 'y':2.3}
                          ,{'x':end_pos_x+0.9, 'y':2.3}] 
                          ,'F.SilkS', 0.15)

for i in range(0, pincount-1):
    middle_x = start_pos_x+1+i*2
    start_x = middle_x-0.1
    end_x = middle_x+0.1
    kicad_mod.addLine({'x':start_x, 'y':3.1}, {'x':end_x, 'y':3.1}, 'F.SilkS', 0.15)
    kicad_mod.addLine({'x':start_x, 'y':2.3}, {'x':end_x, 'y':2.3}, 'F.SilkS', 0.15)
    kicad_mod.addPolygoneLine([{'x':start_x, 'y':2.3}
                              ,{'x':start_x, 'y':1.8}
                              ,{'x':end_x, 'y':1.8}
                              ,{'x':end_x, 'y':2.3}], 'F.SilkS', 0.15)
    kicad_mod.addLine({'x':middle_x, 'y':2.3}, {'x':middle_x, 'y':1.8}, 'F.SilkS', 0.15)

kicad_mod.addCircle({'x':start_pos_x-2.95+0.8+0.75, 'y':3.1+0.75}, {'x':0.25, 'y':0}, 'F.SilkS', 0.15)

# create Courtyard
kicad_mod.addRectLine({'x':start_pos_x-1.6-1.6-0.5, 'y':5.6+0.275 + 0.25}, {'x':end_pos_x+1.6+1.6+0.5, 'y':-1.9-0.275-0.25}, 'F.CrtYd', 0.05)

# create pads
createNumberedPadsSMD(kicad_mod, pincount, 2, {'x':1, 'y':5.5}, 4.75-1.9) #TODO y
kicad_mod.addPad('""', 'smd', 'rect', {'x':start_pos_x-1.6-1.6/2, 'y':0.6}, {'x':1.6, 'y':3}, 0, ['F.Cu', 'F.Paste', 'F.Mask'])
kicad_mod.addPad('""', 'smd', 'rect', {'x':end_pos_x+1.6+1.6/2, 'y':0.6}, {'x':1.6, 'y':3}, 0, ['F.Cu', 'F.Paste', 'F.Mask'])

# output kicad model
print(kicad_mod)
                {"x": x - p, "y": y - 5 * p},
                {"x": x + p, "y": y - 5 * p},
                {"x": x + p, "y": y + p},
            ]
        )

    # add courtyard

    # courtyard corners
    cx1 = -B / 2 - 0.5
    cx2 = B / 2 + 0.5

    cy1 = -6.1
    cy2 = 0.55

    # make sure they lie on an 0.05mm grid

    cx1 = int(cx1 / 0.05) * 0.05
    cx2 = int(cx2 / 0.05) * 0.05

    cy1 = int(cy1 / 0.05) * 0.05
    cy2 = int(cy2 / 0.05) * 0.05

    kicad_mod.addRectLine({"x": cx1, "y": cy1}, {"x": cx2, "y": cy2}, "F.CrtYd", 0.05)

    f = open(footprint_name + ".kicad_mod", "w")

    f.write(kicad_mod.__str__())

    f.close()
pincount = int(args.pincount[0])

# Through-hole type shrouded header, Top entry type
footprint_name = 'JST_PH_B{pincount}B-PH-K_{pincount:02}x2.00mm_Straight'.format(pincount=pincount)

kicad_mod = KicadMod(footprint_name)
kicad_mod.setDescription("http://www.jst-mfg.com/product/pdf/eng/ePH.pdf")
kicad_mod.setTags('connector jst ph')

# set general values
kicad_mod.addText('reference', 'REF**', {'x':0, 'y':-3}, 'F.SilkS')
kicad_mod.addText('value', footprint_name, {'x':(pincount-1)*2/2, 'y':4}, 'F.Fab')

# create Silkscreen
kicad_mod.addRectLine({'x':-1.95, 'y':2.8}, {'x':(pincount-1)*2+1.95, 'y':-1.7}, 'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':0.5, 'y':-1.7}
                          ,{'x':0.5, 'y':-1.2}
                          ,{'x':-1.45, 'y':-1.2}
                          ,{'x':-1.45, 'y':2.3}
                          ,{'x':(pincount-1)*2+1.45, 'y':2.3}
                          ,{'x':(pincount-1)*2+1.45, 'y':-1.2}
                          ,{'x':(pincount-1)*2-0.5, 'y':-1.2}
                          ,{'x':(pincount-1)*2-0.5, 'y':-1.7}], 'F.SilkS', 0.15)

kicad_mod.addLine({'x':-1.95, 'y':-0.5}, {'x':-1.45, 'y':-0.5}, 'F.SilkS', 0.15)
kicad_mod.addLine({'x':-1.95, 'y':0.8}, {'x':-1.45, 'y':0.8}, 'F.SilkS', 0.15)

kicad_mod.addLine({'x':(pincount-1)*2+1.45, 'y':-0.5}, {'x':(pincount-1)*2+1.95, 'y':-0.5}, 'F.SilkS', 0.15)
kicad_mod.addLine({'x':(pincount-1)*2+1.45, 'y':0.8}, {'x':(pincount-1)*2+1.95, 'y':0.8}, 'F.SilkS', 0.15)
Пример #12
0
}, {
    'x': -1.95 + 0.7,
    'y': 0.25
}, 'F.SilkS', 0.15)
kicad_mod.addLine({
    'x': (pincount - 1) * 2 + 1.95,
    'y': 0.25
}, {
    'x': (pincount - 1) * 2 + 1.95 - 0.7,
    'y': 0.25
}, 'F.SilkS', 0.15)

kicad_mod.addRectLine({
    'x': -1.3,
    'y': 2.5
}, {
    'x': -0.3,
    'y': 4.1
}, 'F.SilkS', 0.15)
kicad_mod.addRectLine({
    'x': (pincount - 1) * 2 + 1.3,
    'y': 2.5
}, {
    'x': (pincount - 1) * 2 + 0.3,
    'y': 4.1
}, 'F.SilkS', 0.15)
kicad_mod.addLine({
    'x': -0.3,
    'y': 4.1
}, {
    'x': -0.3,
kicad_mod.addLine({'x':start_pos_x-0.4, 'y':4.575}, {'x':end_pos_x+0.4, 'y':4.575}, 'F.SilkS', 0.15)

'''
kicad_mod.addPolygoneLine([{'x':start_pos_x+0.5, 'y':4.575}
                          ,{'x':start_pos_x+0.5, 'y':4.575-1}
                          ,{'x':end_pos_x-0.5, 'y':4.575-1}
                          ,{'x':end_pos_x-0.5, 'y':4.575}]
                          ,'F.SilkS', 0.15)
'''

kicad_mod.addPolygoneLine([{'x':start_pos_x-1.5, 'y':3.875-1.2}
                          ,{'x':start_pos_x-1.5, 'y':4.575-4.25}
                          ,{'x':start_pos_x-0.6, 'y':4.575-4.25}]
                          ,'F.SilkS', 0.15)

kicad_mod.addRectLine({'x':start_pos_x-1, 'y':4.575-4.25}, {'x':start_pos_x-1, 'y':4.575-4.25+1.2}, 'F.SilkS', 0.15)
kicad_mod.addRectLine({'x':start_pos_x-1, 'y':4.575-4.25+0.5}, {'x':start_pos_x-1.5, 'y':4.575-4.25+0.5}, 'F.SilkS', 0.15)
kicad_mod.addRectLine({'x':start_pos_x-1, 'y':4.575-4.25+1.2}, {'x':start_pos_x-1.5, 'y':4.575-4.25+1.2}, 'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':end_pos_x+1.5, 'y':3.875-1.2}
                          ,{'x':end_pos_x+1.5, 'y':4.575-4.25}
                          ,{'x':end_pos_x+0.6, 'y':4.575-4.25}]
                          ,'F.SilkS', 0.15)

kicad_mod.addRectLine({'x':end_pos_x+1, 'y':4.575-4.25}, {'x':end_pos_x+1, 'y':4.575-4.25+1.2}, 'F.SilkS', 0.15)
kicad_mod.addRectLine({'x':end_pos_x+1, 'y':4.575-4.25+0.5}, {'x':end_pos_x+1.5, 'y':4.575-4.25+0.5}, 'F.SilkS', 0.15)
kicad_mod.addRectLine({'x':end_pos_x+1, 'y':4.575-4.25+1.2}, {'x':end_pos_x+1.5, 'y':4.575-4.25+1.2}, 'F.SilkS', 0.15)

kicad_mod.addCircle({'x':start_pos_x-1, 'y':-0.25}, {'x':0.25, 'y':0}, 'F.SilkS', 0.15)

# create Courtyard
                          ,{'x':(pincount-1)*2+1.95, 'y':-1.35}
                          ,{'x':(pincount-1)*2+1.95-0.7, 'y':-1.35}
                          ,{'x':(pincount-1)*2+1.95-0.7, 'y':0.25}
                          ,{'x':(pincount-1)*2+0.9, 'y':0.25}]
                         ,'F.SilkS', 0.15) #TODO

kicad_mod.addPolygoneLine([{'x':0, 'y':-1.2}
                          ,{'x':-0.4, 'y':-1.6}
                          ,{'x':0.4, 'y':-1.6}
                          ,{'x':0, 'y':-1.2}]
                          ,'F.SilkS', 0.15)

kicad_mod.addLine({'x':-1.95, 'y':0.25}, {'x':-1.95+0.7, 'y':0.25}, 'F.SilkS', 0.15)
kicad_mod.addLine({'x':(pincount-1)*2+1.95, 'y':0.25}, {'x':(pincount-1)*2+1.95-0.7, 'y':0.25}, 'F.SilkS', 0.15)

kicad_mod.addRectLine({'x':-1.3, 'y':2.5}, {'x':-0.3, 'y':4.1}, 'F.SilkS', 0.15)
kicad_mod.addRectLine({'x':(pincount-1)*2+1.3, 'y':2.5}, {'x':(pincount-1)*2+0.3, 'y':4.1}, 'F.SilkS', 0.15)
kicad_mod.addLine({'x':-0.3, 'y':4.1}, {'x':-0.3, 'y':6.25}, 'F.SilkS', 0.15)
kicad_mod.addLine({'x':-0.8, 'y':4.1}, {'x':-0.8, 'y':6.25}, 'F.SilkS', 0.15)

for i in range(0, pincount-1):
    middle_x = 1+i*2
    start_x = middle_x-0.1
    end_x = middle_x+0.1
    kicad_mod.addLine({'x':start_x, 'y':0.25}, {'x':end_x, 'y':0.25}, 'F.SilkS', 0.15)

# create Courtyard
kicad_mod.addRectLine({'x':-1.95-0.5, 'y':6.25+0.5}, {'x':(pincount-1)*2+1.95+0.5, 'y':-1.35-0.5}, 'F.CrtYd', 0.05)

# create pads
createNumberedPadsTHT(kicad_mod, pincount, 2, 0.7, {'x':1.2, 'y':1.7})
        A = (pincount - 1) * 1.5
        B = A + 4.5

        #outline
        x1 = -1.55 - 0.7
        x2 = x1 + B

        xMid = x1 + B/2

        y2 = 0.65
        y1 = y2 - 5.75
        
        #add outline to F.Fab
        kicad_mod.addRectLine(
            {'x': x1, 'y': y1},
            {'x': x2, 'y': y2},
            'F.Fab', 0.15
            )

        #expand the outline a little bit
        out = 0.15
        x1 -= out
        x2 += out
        y1 -= out
        y2 += out

        # set general values
        kicad_mod.addText('reference', 'REF**', {'x':xMid, 'y':2}, 'F.SilkS')
        kicad_mod.addText('value', footprint_name, {'x':xMid, 'y':-6.5}, 'F.Fab')

        dia = 1.3
                          },
                          starting=2,
                          increment=2,
                          y_off=y_spacing,
                          x_off=pitch)

    #add mounting hole (only for the -1D option which has the boss)
    if boss:
        kicad_mod.addMountingHole({'x': -1.65, 'y': -3.8}, 1.1)

    #draw the courtyard
    cy = 0.5
    kicad_mod.addRectLine({
        'x': x1 - 0.5,
        'y': y1 - 0.5
    }, {
        'x': x2 + 0.5,
        'y': y2 + 0.5
    }, "F.CrtYd", 0.05)

    kicad_mod.addRectLine({'x': x1, 'y': y1}, {'x': x2, 'y': y2})

    #draw the line at the top

    #thicknes t of sidewalls
    t = 0.8
    xa = xMid - A / 2 - 0.25 + out
    xb = xMid + A / 2 + 0.25 - out
    y3 = y1 + 1.7

    q = 0.4  #inner rect offset
 {'x': x2-t,'y': y1+t},
 {'x': xo,'y': y1+t},
 {'x': xo,'y': y1},
 ])
 
 #draw bottom line
 xa = -A/2 + o
 xb =  A/2 - o
 
 xo = mx - mw/2 - o
 
 #boss thickness b
 b = 1.5
 
 kicad_mod.addRectLine(
 {'x': -xo, 'y': y2 - b},
 {'x':  xo, 'y': y2}
 )
 
 #inner rect
 #rect thickness r
 r = 0.4
 kicad_mod.addRectLine(
 {'x': xa+r,'y': y2-b+r},
 {'x': xb-r,'y': y2-r})
 
 #left hand wall
 kicad_mod.addLine(
 {'x':  xa,'y': y2-b},
 {'x':  xa,'y': y2}
 )
 
Пример #18
0
# set general values
kicad_mod.addText('reference', 'REF**', {
    'x': start_pos_x + 1,
    'y': -4.5
}, 'F.SilkS')
kicad_mod.addText('value', footprint_name, {
    'x': (pincount - 1) * pad_spacing / 2.,
    'y': 4.5
}, 'F.Fab')

# create Silkscreen

kicad_mod.addRectLine({
    'x': start_pos_x - 2.54 / 2 - 0.1,
    'y': -3.02
}, {
    'x': end_pos_x + 2.54 / 2 + 0.1,
    'y': 2.98
}, 'F.SilkS', 0.15)

#ramps
if pincount <= 6:
    # single ramp
    kicad_mod.addPolygoneLine([{
        'x': start_pos_x,
        'y': 2.98
    }, {
        'x': start_pos_x,
        'y': 1.98
    }, {
        'x': end_pos_x,
kicad_mod.setTags('connector jst sh')
kicad_mod.setCenterPos({'x':0, 'y':2.525/2})

# set general values
kicad_mod.addText('reference', 'REF**', {'x':start_pos_x, 'y':-2-0.2375}, 'F.SilkS')
kicad_mod.addText('value', footprint_name, {'x':0, 'y':4.5+0.2625}, 'F.Fab')

# create Silkscreen
kicad_mod.addLine({'x':start_pos_x-0.4, 'y':-0.7}, {'x':end_pos_x+0.4, 'y':-0.7}, 'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':start_pos_x-1.5, 'y':1.2}
                          ,{'x':start_pos_x-1.5, 'y':2.2}
                          ,{'x':start_pos_x-0.6, 'y':2.2}]
                          ,'F.SilkS', 0.15)

kicad_mod.addRectLine({'x':start_pos_x-1, 'y':2.2}, {'x':start_pos_x-1, 'y':1.2}, 'F.SilkS', 0.15)
kicad_mod.addRectLine({'x':start_pos_x-1, 'y':1.6}, {'x':start_pos_x-1.5, 'y':1.6}, 'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':end_pos_x+1.5, 'y':1.2}
                          ,{'x':end_pos_x+1.5, 'y':2.2}
                          ,{'x':end_pos_x+0.6, 'y':2.2}]
                          ,'F.SilkS', 0.15)

kicad_mod.addRectLine({'x':end_pos_x+1, 'y':2.2}, {'x':end_pos_x+1, 'y':1.2}, 'F.SilkS', 0.15)
kicad_mod.addRectLine({'x':end_pos_x+1, 'y':1.6}, {'x':end_pos_x+1.5, 'y':1.6}, 'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':start_pos_x-0.4, 'y':0.2}
                          ,{'x':start_pos_x-0.4, 'y':-0.3}
                          ,{'x':end_pos_x+0.4, 'y':-0.3}
                          ,{'x':end_pos_x+0.4, 'y':0.2}] 
                          ,'F.SilkS', 0.15)
Пример #20
0
            'x': x - p,
            'y': y - p
        }, {
            'x': x - p,
            'y': y + p
        }, {
            'x': x + p,
            'y': y + p
        }, {
            'x': x + p,
            'y': y - p
        }, {
            'x': x - p,
            'y': y - p
        }])

    #add courtyard
    kicad_mod.addRectLine({
        'x': -B / 2 - 0.5,
        'y': -6.125
    }, {
        'x': B / 2 + 0.5,
        'y': 0.525
    }, 'F.CrtYd', 0.05)

    f = open(footprint_name + ".kicad_mod", "w")

    f.write(kicad_mod.__str__())

    f.close()
# Through-hole type shrouded header, Top entry type
footprint_name = 'Multicomp_MC9A12-{pincount:02g}34_2x{pincount_half:02g}x2.54mm_Straight'.format(pincount=pincount, pincount_half=pincount/2) # TODO: name

kicad_mod = KicadMod(footprint_name)
kicad_mod.setDescription('http://www.farnell.com/datasheets/1520732.pdf')
kicad_mod.setTags('connector multicomp MC9A MC9A12')

# set general values
kicad_mod.addText('reference', 'REF**', {'x':start_pos_x-3, 'y':-7}, 'F.SilkS')
kicad_mod.addText('value', footprint_name, {'x':end_pos_x/2., 'y':5}, 'F.Fab')

# create Silkscreen

# outline
kicad_mod.addRectLine({'x':start_pos_x-3.87-1.2, 'y':3.2}, {'x':end_pos_x+3.87+1.2, 'y':-pad_spacing-3.2}, 'F.SilkS', 0.15)

# slot(s)
if pincount < 60:
    kicad_mod.addPolygoneLine([{'x':((start_pos_x+end_pos_x)/2)-4.45/2, 'y':3.2}
                              ,{'x':((start_pos_x+end_pos_x)/2)-4.45/2, 'y':1.9}
                              ,{'x':start_pos_x-3.87, 'y':1.9}
                              ,{'x':start_pos_x-3.87, 'y':-pad_spacing-1.9}
                              ,{'x':end_pos_x+3.87, 'y':-pad_spacing-1.9}
                              ,{'x':end_pos_x+3.87, 'y':1.9}
                              ,{'x':((start_pos_x+end_pos_x)/2)+4.45/2, 'y':1.9}
                              ,{'x':((start_pos_x+end_pos_x)/2)+4.45/2, 'y':3.2}], 'F.SilkS', 0.15)
else:
    kicad_mod.addPolygoneLine([{'x':((start_pos_x+end_pos_x)/2)-4.45/2-7.3-4.1, 'y':3.2}
                              ,{'x':((start_pos_x+end_pos_x)/2)-4.45/2-7.3-4.1, 'y':1.9}
                              ,{'x':start_pos_x-3.87, 'y':1.9}
Пример #22
0
        'y': -8.5 - 0.675
    }, 'F.SilkS')
    kicad_mod.addText('value', footprint_name, {'x': 0, 'y': 2}, 'F.Fab')

    #outline
    x1 = -B / 2
    x2 = B / 2

    y2 = -0.4
    y1 = y2 - 5.8

    #add outline to F.Fab
    kicad_mod.addRectLine({
        'x': x1,
        'y': y1
    }, {
        'x': x2,
        'y': y2
    }, 'F.Fab', 0.15)

    #expand the outline a little bit
    out = 0.2
    x1 -= out
    x2 += out
    y1 -= out
    y2 += out

    #pad size
    pw = 0.9
    ph = 2.5
    mpad_w = 1.0
    mpad_h = 2.8
    mpad_x = (B/2) - (mpad_w/2)
    mpad_y = -1.35

    kicad_mod.addPad('""', 'smd', 'rect', {'x':mpad_x, 'y':mpad_y}, {'x':mpad_w, 'y':mpad_h}, 0, ['F.Cu', 'F.Paste', 'F.Mask'])
    kicad_mod.addPad('""', 'smd', 'rect', {'x':-mpad_x, 'y':mpad_y}, {'x':mpad_w, 'y':mpad_h}, 0, ['F.Cu', 'F.Paste', 'F.Mask'])

    T = 0.5
    
    y1 = -4.25
    y2 = y1 + 4.05
    #add outline to F.Fab
    kicad_mod.addRectLine(
        {'x': -B/2,'y': y1},
        {'x':  B/2,'y': y2},
        'F.Fab', 0.15
    )
    
    #add bottom line
    kicad_mod.addPolygoneLine([{'x':-B/2+mpad_w+0.6,'y':-0.1},
                            {'x':B/2-mpad_w-0.6,'y':-0.1}])
                             
    #add left line
    kicad_mod.addPolygoneLine([{'x':-B/2-0.1,'y':-3.3},
                                {'x':-B/2-0.1,'y':-4.4},
                                {'x':-A/2-pad_w/2-0.5,'y':-4.4},
                                {'x':-A/2-pad_w/2-0.5,'y':-4.4+T},
                                {'x':-B/2-0.1+T,'y':-4.4+T},
                                {'x':-B/2-0.1+T,'y':-3.3},
                                {'x':-B/2-0.1,'y':-3.3}])
                              

    kicad_mod.addPolygoneLine([{'x':x1,'y':y1},
                               {'x':x1-0.25,'y':y1-0.5},
                               {'x':x1+0.25,'y':y1-0.5},
                               {'x':x1,'y':y1}])
                               
                               
    #add picture of each pin
    p = 0.25
    
    y = -2.5 

    for i in range(pincount):
    
        x = x1 + (i * pad_spacing)
        kicad_mod.addPolygoneLine([{'x': x-p,'y': y-p},
                                   {'x': x-p,'y': y+p},
                                   {'x': x+p,'y': y+p},
                                   {'x': x+p,'y': y-p},
                                   {'x': x-p,'y': y-p}])
                              
    #add courtyard
    kicad_mod.addRectLine({'x':-B/2-0.5,'y':-6.125},{'x':B/2+0.5,'y':0.525},'F.CrtYd',0.05)

    f = open(footprint_name + ".kicad_mod","w")

    f.write(kicad_mod.__str__())

    f.close()
Пример #25
0
kicad_mod.addPolygoneLine([{
    'x': start_pos_x - 1.5,
    'y': 3.875 - 1.2
}, {
    'x': start_pos_x - 1.5,
    'y': 4.575 - 4.25
}, {
    'x': start_pos_x - 0.6,
    'y': 4.575 - 4.25
}], 'F.SilkS', 0.15)

kicad_mod.addRectLine({
    'x': start_pos_x - 1,
    'y': 4.575 - 4.25
}, {
    'x': start_pos_x - 1,
    'y': 4.575 - 4.25 + 1.2
}, 'F.SilkS', 0.15)
kicad_mod.addRectLine({
    'x': start_pos_x - 1,
    'y': 4.575 - 4.25 + 0.5
}, {
    'x': start_pos_x - 1.5,
    'y': 4.575 - 4.25 + 0.5
}, 'F.SilkS', 0.15)
kicad_mod.addRectLine({
    'x': start_pos_x - 1,
    'y': 4.575 - 4.25 + 1.2
}, {
    'x': start_pos_x - 1.5,
Пример #26
0
    kicad_mod = KicadMod(footprint_name)
    kicad_mod.setDescription("JST GH series connector, " + jst_name +
                             ", top entry type")
    kicad_mod.setAttribute('smd')
    kicad_mod.setTags('connector jst GH SMT top vertical entry 1.25mm pitch')

    kicad_mod.setCenterPos({'x': 0, 'y': 3.075})

    #draw outline on the F.Fab layer
    y1 = 4.25 / 2 + 2.25
    y2 = y1 - 4.25
    kicad_mod.addRectLine({
        'x': -B / 2,
        'y': y1
    }, {
        'x': B / 2,
        'y': y2
    }, 'F.Fab', 0.10)

    # set general values
    kicad_mod.addText('reference', 'REF**', {'x': 0, 'y': -1.5}, 'F.SilkS')
    kicad_mod.addText('user', '%R', {'x': 0, 'y': 1.25}, 'F.Fab')
    kicad_mod.addText('value', footprint_name, {'x': 0, 'y': 6.75}, 'F.Fab')

    #create outline
    # create Courtyard
    # output kicad model

    #create pads
    createNumberedPadsSMD(kicad_mod,
Пример #27
0
                          starting=2,
                          increment=2,
                          y_off=y_spacing,
                          x_off=pitch)

    #add mounting holes
    kicad_mod.addMountingHole({'x': -1.55, 'y': 1.85}, 1.1)

    kicad_mod.addMountingHole({'x': A + 1.55, 'y': 1.85}, 1.1)

    #draw the courtyard
    cy = 0.5
    kicad_mod.addRectLine({
        'x': x1 - 0.5,
        'y': y1 - 0.5
    }, {
        'x': x2 + 0.5,
        'y': y2 + 0.5
    }, "F.CrtYd", 0.05)

    kicad_mod.addRectLine({'x': x1, 'y': y1}, {'x': x2, 'y': y2})

    #draw the line at the bottom

    xa = xMid - A / 2 + out
    xb = xMid + A / 2 - out
    y3 = y2 - 1
    kicad_mod.addPolygoneLine([{
        'x': xa,
        'y': y2
    }, {
Пример #28
0
        'x': B / 2 + o,
        'y': -4.45
    }, {
        'x': A / 2 + pad_w / 2 + 0.5,
        'y': -4.45
    }],
                              width=0.12)

    #add connector outline to F.Fab
    y1 = -4.3
    y2 = y1 + 4.3

    kicad_mod.addRectLine({
        'x': -B / 2,
        'y': y1
    }, {
        'x': B / 2,
        'y': y2
    }, 'F.Fab', 0.1)

    x1 = -B / 2 + 1

    y1 = -5

    marker = [{
        'x': x1,
        'y': y1
    }, {
        'x': x1 - 0.5,
        'y': y1 - 0.25
    }, {
Пример #29
0
    kicad_mod.addText('reference', 'REF**', {
        'x': 0,
        'y': -8.5 - 0.675
    }, 'F.SilkS')
    kicad_mod.addText('user', '%R', {'x': 0, 'y': -1.25}, 'F.Fab')
    kicad_mod.addText('value', footprint_name, {'x': 0, 'y': 2}, 'F.Fab')

    #outline
    x1 = -B / 2
    x2 = B / 2

    y2 = -0.4
    y1 = y2 - 5.8

    #add outline to F.Fab
    kicad_mod.addRectLine({'x': x1, 'y': y1}, {'x': x2, 'y': y2}, 'F.Fab', 0.1)

    #expand the outline a little bit
    out = 0.2
    x1 -= out
    x2 += out
    y1 -= out
    y2 += out

    #pad size
    pw = 0.9
    ph = 2.5

    #create dem pads
    createNumberedPadsSMD(kicad_mod, pincount, -pitch, {'x': pw, 'y': ph}, py)
Пример #30
0
 x1 = -(B-A) / 2
 y1 = -2.2
 x2 = x1 + B
 y2 = 1.2
 
 #line offset 
 off = 0.1
 
 x1 -= off
 y1 -= off
 
 x2 += off
 y2 += off
 
 #draw the main outline around the footprint
 kicad_mod.addRectLine({'x':x1,'y':y1},{'x':x2,'y':y2})
 
 #add pin-1 marker
 
 xm = 0
 ym = -2.8
 
 m = 0.3
 
 kicad_mod.addPolygoneLine([{'x':xm,'y':ym},
                            {'x':xm - m,'y':ym - 2 * m},
                            {'x':xm + m,'y':ym - 2 * m},
                            {'x':xm,'y':ym}])
                            
 #side-wall thickness S
 
end_pos_x = (pincount-1)*pad_spacing

# Through-hole type shrouded header, Top entry type
footprint_name = 'Molex_KK_6410-{pincount:02g}'.format(pincount=pincount) # TODO: name

kicad_mod = KicadMod(footprint_name)
kicad_mod.setDescription("Connector Headers with Friction Lock, 22-27-2{pincount:02g}1, http://www.molex.com/pdm_docs/sd/022272021_sd.pdf".format(pincount=pincount))
kicad_mod.setTags('connector molex kk_6410 22-27-2{pincount:02g}1'.format(pincount=pincount))

# set general values
kicad_mod.addText('reference', 'REF**', {'x':start_pos_x+1, 'y':-4.5}, 'F.SilkS')
kicad_mod.addText('value', footprint_name, {'x':(pincount-1)*pad_spacing/2., 'y':4.5}, 'F.Fab')

# create Silkscreen

kicad_mod.addRectLine({'x':start_pos_x-2.54/2-0.1, 'y':-3.02}, {'x':end_pos_x+2.54/2+0.1, 'y':2.98}, 'F.SilkS', 0.15)

#ramps
if pincount <= 6:
    # single ramp
    kicad_mod.addPolygoneLine([{'x':start_pos_x, 'y':2.98}
                              ,{'x':start_pos_x, 'y':1.98}
                              ,{'x':end_pos_x, 'y':1.98}
                              ,{'x':end_pos_x, 'y':2.98}], 'F.SilkS', 0.15)
    kicad_mod.addPolygoneLine([{'x':start_pos_x, 'y':1.98}
                              ,{'x':start_pos_x+0.25, 'y':1.55}
                              ,{'x':end_pos_x-0.25, 'y':1.55}
                              ,{'x':end_pos_x, 'y':1.98}], 'F.SilkS', 0.15)
    kicad_mod.addLine({'x':start_pos_x+0.25, 'y':2.98}, {'x':start_pos_x+0.25, 'y':1.98}, 'F.SilkS', 0.15)
    kicad_mod.addLine({'x':end_pos_x-0.25, 'y':2.98}, {'x':end_pos_x-0.25, 'y':1.98}, 'F.SilkS', 0.15)
else:
Пример #32
0
        B = A + 4.5

        #outline
        x1 = -1.55 - 0.7
        x2 = x1 + B

        xMid = x1 + B / 2

        y2 = 0.65
        y1 = y2 - 5.75

        #add outline to F.Fab
        kicad_mod.addRectLine({
            'x': x1,
            'y': y1
        }, {
            'x': x2,
            'y': y2
        }, 'F.Fab', 0.1)

        #expand the outline a little bit
        out = 0.15
        x1 -= out
        x2 += out
        y1 -= out
        y2 += out

        # set general values
        kicad_mod.addText('reference', 'REF**', {'x': xMid, 'y': 2}, 'F.SilkS')
        kicad_mod.addText('user', '%R', {'x': xMid, 'y': -4.25}, 'F.Fab')
        kicad_mod.addText('value', footprint_name, {
kicad_mod = KicadMod(footprint_name)
kicad_mod.setDescription("http://www.jst-mfg.com/product/pdf/eng/ePH.pdf")
kicad_mod.setTags('connector jst ph')

# set general values
kicad_mod.addText('reference', 'REF**', {'x': 0, 'y': -3}, 'F.SilkS')
kicad_mod.addText('value', footprint_name, {
    'x': (pincount - 1) * 2 / 2,
    'y': 4
}, 'F.Fab')

# create Silkscreen
kicad_mod.addRectLine({
    'x': -1.95,
    'y': 2.8
}, {
    'x': (pincount - 1) * 2 + 1.95,
    'y': -1.7
}, 'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{
    'x': 0.5,
    'y': -1.7
}, {
    'x': 0.5,
    'y': -1.2
}, {
    'x': -1.45,
    'y': -1.2
}, {
    'x': -1.45,
    kicad_mod.addPolygoneLine(pin1)
    kicad_mod.addPolygoneLine(pin1, 'F.Fab')

    #add a courtyard
    cy = 0.5

    xo = 0.85

    cx1 = grid(-B / 2 - cy - 0.6) + 0.25
    cy1 = -2.625 + 0.015 + 0.2
    cx2 = grid(B / 2 + cy + 0.6) - 0.25
    cy2 = 4.5 + 1.90 - 0.05 / 2 - 0.085 - 0.1

    kicad_mod.addRectLine({
        'x': cx1,
        'y': cy1
    }, {
        'x': cx2,
        'y': cy2
    }, "F.CrtYd", 0.05)

    kicad_mod.model = "Connectors_Molex.3dshapes/" + footprint_name + ".wrl"

    # output kicad model
    f = open(footprint_name + ".kicad_mod", "w")

    f.write(kicad_mod.__str__())

    f.close()
Пример #35
0
    dia = 1.85

    # create pads
    createNumberedPadsTHT(kicad_mod, pincount, pitch, drill, {
        'x': dia,
        'y': dia
    })

    x1 = -2.5
    y1 = -1.6
    x2 = x1 + B
    y2 = y1 + 3.8

    #draw the main outline on F.Fab layer
    kicad_mod.addRectLine({'x': x1, 'y': y1}, {'x': x2, 'y': y2}, 'F.Fab', 0.1)

    #line offset
    off = 0.15

    x1 -= off
    y1 -= off

    x2 += off
    y2 += off

    #draw the main outline around the footprint
    kicad_mod.addRectLine({'x': x1, 'y': y1}, {'x': x2, 'y': y2}, width=0.12)

    T = 0.5