Python KicadMod.addPolygoneLine Examples

Example #1

File: connectors_jst_ph_tht_top.py Project: joonas-lahtinen/kicad-footprint-generator

    '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,

Example #2

    xo = 0.5

    #thickness of "arms"
    t = 1.9

    #depth of arms
    d = 1.0

    #angle of arms
    a = 0.4

    kicad_mod.addPolygoneLine([{
        'x': -A / 2 - pad_w / 2 - xo,
        'y': y1
    }, {
        'x': x1,
        'y': y1
    }, {
        'x': x1,
        'y': mpad_y - mpad_h / 2 - xo
    }])

    kicad_mod.addPolygoneLine([{
        'x': A / 2 + pad_w / 2 + xo,
        'y': y1
    }, {
        'x': x2,
        'y': y1
    }, {
        'x': x2,
        'y': mpad_y - mpad_h / 2 - xo
    }])

Example #3

File: eh_top_entry_tht.py Project: SchrodingersGat/kicad-footprint-generator

    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

    # add top line
    kicad_mod.addPolygoneLine(
        [
            {"x": x1, "y": 0},
            {"x": x1 + T, "y": 0},
            {"x": x1 + T, "y": y1 + T},
            {"x": x2 - T, "y": y1 + T},
            {"x": x2 - T, "y": 0},
            {"x": x2, "y": 0},
        ]
    )

    # add bottom line (left)
    kicad_mod.addPolygoneLine(
        [{"x": x1, "y": y2 - 3 * T}, {"x": x1 + 2 * T, "y": y2 - 3 * T}, {"x": x1 + 2 * T, "y": y2}]
    )

    # add bottom line (right)
    kicad_mod.addPolygoneLine(
        [{"x": x2, "y": y2 - 3 * T}, {"x": x2 - 2 * T, "y": y2 - 3 * T}, {"x": x2 - 2 * T, "y": y2}]
    )

Example #4

 
 #draw the bottom line
 kicad_mod.addLine({'x':x1,'y':y2},{'x':x2,'y':y2})
 
 a = 0.4
 
 kicad_mod.addLine({'x':x1,'y':y2},{'x':x1,'y':y2-a})
 kicad_mod.addLine({'x':x2,'y':y2},{'x':x2,'y':y2-a})
 
 xm = -A/2- 1
 ym = -1
 
 m = 0.3
 
 kicad_mod.addPolygoneLine([{'x':xm,'y':ym},
                            {'x':xm - 2 * m,'y':ym - m},
                            {'x':xm - 2 * m,'y':ym + m},
                            {'x':xm,'y':ym}])
                            
 
 #add pictures of pins
 #pin-width w
 #pin-length l
 w = 0.25
 
 py = 2.3
 
 for p in range(pincount):
     
     px = -A/2 + p * pitch
     
     kicad_mod.addPolygoneLine([{'x': px-w,'y': py-w},

Example #5

File: connectors_multicomp_mc9a12.py Project: zhdjet/kicad-footprint-generator

# 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(
        [{

Example #6

    m = 0.3

    poly = [{
        'x': xm,
        'y': ym
    }, {
        'x': xm + 2 * m,
        'y': ym - m
    }, {
        'x': xm + 2 * m,
        'y': ym + m
    }, {
        'x': xm,
        'y': ym
    }]
    kicad_mod.addPolygoneLine(poly)
    kicad_mod.addPolygoneLine(poly, layer='F.Fab')

    #wall thickness t
    t = 0.8
    #line offset from pads o
    o = 0.5
    xo = A / 2 + pw / 2 + o  #horizontal distance from numbered pads
    yo = my - mh / 2 - o
    #draw left-hand line
    kicad_mod.addPolygoneLine([
        {
            'x': -xo,
            'y': y1
        },
        {

Example #7

File: connectors_jst_ph_smd_top.py Project: joonas-lahtinen/kicad-footprint-generator

# set general values
kicad_mod.addText('reference', 'REF**', {
    'x': start_pos_x - 0.5,
    'y': -3 - 0.275
}, 'F.SilkS')
kicad_mod.addText('value', footprint_name, {'x': 0, 'y': 7 - 0.025}, 'F.Fab')

# create Silkscreen

kicad_mod.addPolygoneLine([{
    'x': start_pos_x - 3,
    'y': -1.3
}, {
    'x': start_pos_x - 3,
    'y': -1.9
}, {
    'x': end_pos_x + 3,
    'y': -1.9
}, {
    'x': end_pos_x + 3,
    'y': -1.3
}], 'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{
    'x': start_pos_x - 3,
    'y': 2.5
}, {
    'x': start_pos_x - 3,
    'y': 3.1
}, {
    'x': start_pos_x - 0.9,

Example #8

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

# create Silkscreen
kicad_mod.addPolygoneLine([{
    'x': 0.5,
    'y': 6.25
}, {
    'x': 0.5,
    'y': 2
}, {
    'x': (pincount - 1) * 2 - 0.5,
    'y': 2
}, {
    'x': (pincount - 1) * 2 - 0.5,
    'y': 6.25
}], 'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{
    'x': -0.9,
    'y': 0.25
}, {
    'x': -1.95 + 0.7,
    'y': 0.25
}, {
    'x': -1.95 + 0.7,

Example #9

File: connectors_jst_ph_tht_top.py Project: SchrodingersGat/kicad-footprint-generator

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)

kicad_mod.addPolygoneLine([{'x':-0.3, 'y':-1.7}
                          ,{'x':-0.3, 'y':-1.9}
                          ,{'x':-0.6, 'y':-1.9}
                          ,{'x':-0.6, 'y':-1.7}], 'F.SilkS', 0.15)
kicad_mod.addLine({'x':-0.3, 'y':-1.8}, {'x':-0.6, 'y':-1.8}, 'F.SilkS', 0.15)

Example #10

File: pin_header_2mm.py Project: SchrodingersGat/kicad-footprint-generator

                num = r + 1 + (p * rows)
                
                if num == 1: type = "rect"
                else: type = "circle"
                
                kicad_mod.addPad(num, "thru_hole", type, {'x':X,'y':Y}, {'x':size,'y':size}, drill, ['*.Cu', '*.Mask'])

        #add an outline around the pins
        
        y1 = -1
        x1 = -1
        x2 = (rows - 1) * pitch + 1
        y2 = (pincount - 1) * pitch + 1
        
        if rows == 1:
            kicad_mod.addPolygoneLine([{'x':x1,'y':y1 + pitch},{'x':x2,'y':y1+pitch}])
            
        elif rows == 2:
            kicad_mod.addPolygoneLine([{'x':x1,'y':y1 + pitch},
                                       {'x':x1 + pitch,'y':y1+pitch},
                                       {'x':x1 + pitch,'y':y1},
                                       {'x':x2,'y':y1},
                                       {'x':x2,'y':y1+pitch}])
        
        kicad_mod.addPolygoneLine([
                                   {'x':x2,'y':y1 + pitch},
                                   {'x':x2,'y':y2},
                                   {'x':x1,'y':y2},
                                   {'x':x1,'y':y1 + pitch}])
        
        d = 0.6

Example #11

File: connectors_multicomp_mc9a22.py Project: zhdjet/kicad-footprint-generator

# outline

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


# slot(s)
def draw_pin_silk(slot_pin_x):
    kicad_mod.addPolygoneLine([{'x':slot_pin_x-0.4, 'y':-pad_spacing-1.8-8.9+6.6}
                              ,{'x':slot_pin_x-0.4, 'y':-pad_spacing-1.8-8.5}
                              ,{'x':slot_pin_x-0.2, 'y':-pad_spacing-1.8-8.7}
                              ,{'x':slot_pin_x+0.2, 'y':-pad_spacing-1.8-8.7}
                              ,{'x':slot_pin_x+0.4, 'y':-pad_spacing-1.8-8.5}
                              ,{'x':slot_pin_x+0.4, 'y':-pad_spacing-1.8-8.9+6.6}], 'F.SilkS', 0.15)
                              
kicad_mod.addPolygoneLine([{'x':((start_pos_x+end_pos_x)/2)-4.45/2, 'y':-pad_spacing-1.8-8.9}
                          ,{'x':((start_pos_x+end_pos_x)/2)-4.45/2, 'y':-pad_spacing-1.8-8.9+6.6}
                          ,{'x':((start_pos_x+end_pos_x)/2)+4.45/2, 'y':-pad_spacing-1.8-8.9+6.6}
                          ,{'x':((start_pos_x+end_pos_x)/2)+4.45/2, 'y':-pad_spacing-1.8-8.9}], 'F.SilkS', 0.15)

if pincount%4 != 0:
    slot_pin_x = start_pos_x+((int)(pincount/4)*pad_spacing)

    draw_pin_silk(slot_pin_x)
else:
    slot_pin_x = start_pos_x+((int)(pincount/4-1)*pad_spacing)
    draw_pin_silk(slot_pin_x)
    
    slot_pin_x = start_pos_x+((int)(pincount/4)*pad_spacing)
    draw_pin_silk(slot_pin_x)
    
    if pincount >= 60:
        slot_pin_x = start_pos_x+((int)(pincount/4-1-4)*pad_spacing)

Example #12

    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.1
    )
    
    #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}], width=0.12)
                             
    #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}], width=0.12)

    #add right 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},

Example #13

File: ze-top-entry-tht.py Project: andrewjrobinson/kicad-footprint-generator

 kicad_mod.addRectLine(
     {'x': xa,'y': y1},
     {'x': xb,'y': y3}
     )
     
 #inner rect
 kicad_mod.addRectLine(
     {'x': xa+q,'y': y1+q},
     {'x': xb-q,'y': y3-q}
     )
 
 #left side
 if not boss:
     kicad_mod.addPolygoneLine([
         {'x': xa,'y': y3},
         {'x': x1+t,'y':y3},
         {'x': x1+t,'y':y2-t},
         {'x': -1,'y':y2-t},
     ])
 else: #boss were declared
     kicad_mod.addLine(
         {'x': xa,'y': y3},
         {'x': -0.9,'y': y3}
         )
         
     kicad_mod.addPolygoneLine([
         {'x': x1+t,'y': -3},
         {'x': x1+t,'y': y2-t},
         {'x': -1,'y': y2-t},
     ])
 #right side
 

Example #14

File: connectors_jst_sh_smd_side.py Project: SchrodingersGat/kicad-footprint-generator

kicad_mod = KicadMod(footprint_name)
kicad_mod.setDescription("http://www.jst-mfg.com/product/pdf/eng/eSH.pdf")
kicad_mod.setAttribute('smd')
kicad_mod.setTags('connector jst sh')
kicad_mod.setCenterPos({'x':0, 'y':3.875/2})

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

# create Silkscreen

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)

Example #15

    '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

Example #16

File: eh_side_entry_tht.py Project: andrewjrobinson/kicad-footprint-generator

 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 = 1.5
 
 y3 = y2 - 2.2
 
 kicad_mod.addPolygoneLine([{'x':x1+T,'y':y3},
                            {'x':x1+T,'y':y2},
                            {'x':x1,'y':y2},
                            {'x':x1,'y':y1},
                            {'x':x2,'y':y1},
                            {'x':x2,'y':y2},
                            {'x':x2-T,'y':y2},
                            {'x':x2-T,'y':y3}])
 
 kicad_mod.addPolygoneLine([{'x':x1,'y':y1+T},
                            {'x':x1+T,'y':y1+T},
                            {'x':x1+T,'y':y3},
                            {'x':x1,'y':y3}])
                            
 kicad_mod.addPolygoneLine([{'x':x2,'y':y1+T},
                        {'x':x2-T,'y':y1+T},
                        {'x':x2-T,'y':y3},
                        {'x':x2,'y':y3}])
                        
 

Example #17

        'x': mpad_w,
        'y': mpad_h
    }, 0, ['F.Cu', 'F.Paste', 'F.Mask'])

    #side-wall thickness
    T = 0.5

    #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
    }, {
        'x': B / 2 - mpad_w - 0.6,
        'y': -0.1 - T
    }, {
        'x': -B / 2 + mpad_w + 0.6,
        'y': -0.1 - T
    }, {
        '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

Example #18

File: connectors_jst_ph_smd_top.py Project: SchrodingersGat/kicad-footprint-generator

kicad_mod = KicadMod(footprint_name)
kicad_mod.setDescription("http://www.jst-mfg.com/product/pdf/eng/ePH.pdf")
kicad_mod.setAttribute('smd')
kicad_mod.setTags('connector jst ph')
kicad_mod.setCenterPos({'x':0, 'y':(4.75-1.9+0.6)/2})

# set general values
kicad_mod.addText('reference', 'REF**', {'x':start_pos_x-0.5, 'y':-3-0.275}, 'F.SilkS')
kicad_mod.addText('value', footprint_name, {'x':0, 'y':7-0.025}, 'F.Fab')

# create Silkscreen

kicad_mod.addPolygoneLine([{'x':start_pos_x-3, 'y':-1.3}
                          ,{'x':start_pos_x-3, 'y':-1.9}
                          ,{'x':end_pos_x+3, 'y':-1.9}
                          ,{'x':end_pos_x+3, 'y':-1.3}]
                          ,'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':start_pos_x-3, 'y':2.5}
                          ,{'x':start_pos_x-3, 'y':3.1}
                          ,{'x':start_pos_x-0.9, 'y':3.1}]
                          ,'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':end_pos_x+3, 'y':2.5}
                          ,{'x':end_pos_x+3, 'y':3.1}
                          ,{'x':end_pos_x+0.9, 'y':3.1}]
                          ,'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':start_pos_x+0.5, 'y':-1.9}
                          ,{'x':start_pos_x+0.5, 'y':-1.2}

Example #19

File: connectors_jst_shl_smd_side.py Project: andrewjrobinson/kicad-footprint-generator

    #create pads
    createNumberedPadsSMD(kicad_mod, pincount, pad_spacing, {'x':pad_w,'y':pad_h}, -4.675)

    #add mounting pads (no number)
    mpad_w = 1.0
    mpad_h = 2.0
    mpad_x = (B/2) - (mpad_w/2)
    mpad_y = -0.7 - 1.7/2

    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'])

    #add bottom line
    kicad_mod.addPolygoneLine([{'x':-B/2-0.1,'y':-0.1},
                             {'x':-B/2-0.1,'y':0.2},
                             {'x':B/2+0.1,'y':0.2},
                             {'x':B/2+0.1,'y':-0.1}])
                             
    #add left line
    kicad_mod.addPolygoneLine([{'x':-B/2-0.1,'y':-3.1},
                                {'x':-B/2-0.1,'y':-4.1},
                                {'x':-A/2-pad_w/2-0.5,'y':-4.1}])

    #add right line
    kicad_mod.addPolygoneLine([{'x':B/2+0.1,'y':-3.1},
                                {'x':B/2+0.1,'y':-4.1},
                                {'x':A/2+pad_w/2+0.5,'y':-4.1}])                                  

    #add designator for pin #1

    x1 = -B/2 + 1   

Example #20

File: ze-side-entry-tht.py Project: joonas-lahtinen/kicad-footprint-generator

    }, "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
    }, {
        'x': xa,
        'y': y3
    }, {
        'x': xb,
        'y': y3
    }, {
        'x': xb,
        'y': y2
    }])

    # add pin-1 marker
    D = 0.3
    L = 1.5
    pin_1 = [
        {
            'x': x1 - D,
            'y': y1 - D + L
        },

Example #21

File: socket_strip_2mm.py Project: joonas-lahtinen/kicad-footprint-generator

                    'x': size,
                    'y': size
                }, drill, ['*.Cu', '*.Mask'])

        #add an outline around the pins

        y1 = -1
        x1 = -1
        x2 = (rows - 1) * pitch + 1
        y2 = (pincount - 1) * pitch + 1

        if rows == 1:
            kicad_mod.addPolygoneLine([{
                'y': x1,
                'x': y1 + pitch
            }, {
                'y': x2,
                'x': y1 + pitch
            }])

        elif rows == 2:
            kicad_mod.addPolygoneLine([{
                'y': x1,
                'x': y1 + pitch
            }, {
                'y': x1 + pitch,
                'x': y1 + pitch
            }, {
                'y': x1 + pitch,
                'x': y1
            }, {

Example #22

File: ze-top-entry-smd.py Project: andrewjrobinson/kicad-footprint-generator

    #add pin-1 designation
    xm = A / 2
    ym = py - ph / 2 - 0.5

    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
        },
    ])

    #wall thickness t
    t = 0.8
    #line offset from pads o
    o = 0.5
    xo = A / 2 + pw / 2 + o  #horizontal distance from numbered pads
    yo = my - mh / 2 - o

Example #23

File: socket_strip_2mm.py Project: SchrodingersGat/kicad-footprint-generator

                else:
                    type = "circle"

                kicad_mod.addPad(
                    num, "thru_hole", type, {"x": X, "y": Y}, {"x": size, "y": size}, drill, ["*.Cu", "*.Mask"]
                )

        # add an outline around the pins

        y1 = -1
        x1 = -1
        x2 = (rows - 1) * pitch + 1
        y2 = (pincount - 1) * pitch + 1

        if rows == 1:
            kicad_mod.addPolygoneLine([{"y": x1, "x": y1 + pitch}, {"y": x2, "x": y1 + pitch}])

        elif rows == 2:
            kicad_mod.addPolygoneLine(
                [
                    {"y": x1, "x": y1 + pitch},
                    {"y": x1 + pitch, "x": y1 + pitch},
                    {"y": x1 + pitch, "x": y1},
                    {"y": x2, "x": y1},
                    {"y": x2, "x": y1 + pitch},
                ]
            )

        kicad_mod.addPolygoneLine(
            [{"y": x2, "x": y1 + pitch}, {"y": x2, "x": y2 + 0.2}, {"y": x1, "x": y2 + 0.2}, {"y": x1, "x": y1 + pitch}]
        )

Example #24

File: connectors_jst_gh_smd_side.py Project: pointhi/kicad-footprint-generator

    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

    # 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},
        ]
    )

    # add right line

Example #25

 
 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
 
 S = 0.5
 
 #bottom line
 kicad_mod.addPolygoneLine([{'x':x1,'y':0},
                            {'x':x1+S,'y':0},
                            {'x':x1+S,'y':y2-S},
                            {'x':x2-S,'y':y2-S},
                            {'x':x2-S,'y':0},
                            {'x':x2,'y':0}])
                            
 #left mark

Example #26

File: ze-side-entry-tht.py Project: SchrodingersGat/kicad-footprint-generator

    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},
        {'x':xa,'y':y3},
        {'x':xb,'y':y3},
        {'x':xb,'y':y2}
    ])

    # add pin-1 marker
    D = 0.3
    L = 1.5
    pin_1 = [
        {'x': x1-D,'y': y1-D+L},
        {'x': x1-D,'y':  y1-D},
        {'x': x1-D + L,'y':  y1-D},
    ]
    
    kicad_mod.addPolygoneLine(pin_1)
    kicad_mod.addPolygoneLine(pin_1,layer='F.Fab')
    

Example #27

File: ze-top-entry-tht.py Project: andrewjrobinson/kicad-footprint-generator

    }, {
        'x': xb - q,
        'y': y3 - q
    })

    #left side
    if not boss:
        kicad_mod.addPolygoneLine([
            {
                'x': xa,
                'y': y3
            },
            {
                'x': x1 + t,
                'y': y3
            },
            {
                'x': x1 + t,
                'y': y2 - t
            },
            {
                'x': -1,
                'y': y2 - t
            },
        ])
    else:  #boss were declared
        kicad_mod.addLine({'x': xa, 'y': y3}, {'x': -0.9, 'y': y3})

        kicad_mod.addPolygoneLine([
            {
                'x': x1 + t,
                'y': -3

Example #28

File: ze-top-entry-tht.py Project: SchrodingersGat/kicad-footprint-generator

 kicad_mod.addRectLine(
     {'x': xa,'y': y1},
     {'x': xb,'y': y3}
     )
     
 #inner rect
 kicad_mod.addRectLine(
     {'x': xa+q,'y': y1+q},
     {'x': xb-q,'y': y3-q}
     )
 
 #left side
 if not boss:
     kicad_mod.addPolygoneLine([
         {'x': xa,'y': y3},
         {'x': x1+t,'y':y3},
         {'x': x1+t,'y':y2-t},
         {'x': -1,'y':y2-t},
     ])
 else: #boss were declared
     kicad_mod.addLine(
         {'x': xa,'y': y3},
         {'x': -0.9,'y': y3}
         )
         
     kicad_mod.addPolygoneLine([
         {'x': x1+t,'y': -3},
         {'x': x1+t,'y': y2-t},
         {'x': -1,'y': y2-t},
     ])
 #right side
 

Example #29

File: connectors_molex_kk_6410_top.py Project: SchrodingersGat/kicad-footprint-generator

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:
    # two ramps
    kicad_mod.addPolygoneLine([{'x':start_pos_x, 'y':2.98}
                              ,{'x':start_pos_x, 'y':1.98}
                              ,{'x':start_pos_x+2*pad_spacing, 'y':1.98}
                              ,{'x':start_pos_x+2*pad_spacing, '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}

Example #30

File: panelmate_side.py Project: andrewjrobinson/kicad-footprint-generator

 y2 += off
 
 #offset from pads
 xo = 0.5
 
 #thickness of "arms"
 t = 1.9
 
 #depth of arms
 d = 1.0
 
 #angle of arms
 a = 0.4
 
 kicad_mod.addPolygoneLine([{'x':-A/2 - pad_w/2 - xo,'y':y1},
                            {'x':x1,'y':y1},
                            {'x':x1,'y':mpad_y - mpad_h/2 - xo}])
                            
                            
 kicad_mod.addPolygoneLine([{'x':A/2 + pad_w/2 + xo,'y':y1},
                            {'x':x2,'y':y1},
                            {'x':x2,'y':mpad_y - mpad_h/2 - xo}])                               
 
 
 kicad_mod.addPolygoneLine([{'x':-mpad_x + mpad_w/2 + xo,'y':y2},
                            {'x':x1+t,'y':y2},
                            {'x':x1+t+a,'y':y2-d},
                            {'x':x2-t-a,'y':y2-d},
                            {'x':x2-t,'y':y2},
                            {'x':mpad_x - mpad_w/2 - xo,'y':y2}])
                            

Example #31

    y3 = y2 - 2.2

    kicad_mod.addPolygoneLine([{
        'x': x1 + T,
        'y': y3
    }, {
        'x': x1 + T,
        'y': y2
    }, {
        'x': x1,
        'y': y2
    }, {
        'x': x1,
        'y': y1
    }, {
        'x': x2,
        'y': y1
    }, {
        'x': x2,
        'y': y2
    }, {
        'x': x2 - T,
        'y': y2
    }, {
        'x': x2 - T,
        'y': y3
    }])

    kicad_mod.addPolygoneLine([{
        'x': x1,

Example #32

File: ze-top-entry-smd.py Project: andrewjrobinson/kicad-footprint-generator

 )
 
 kicad_mod.addMountingPad(
 {'x': -mx, 'y': my},
 {'x': mw, 'y': mh}
 )
 
 #add pin-1 designation
 xm = A/2
 ym = py - ph/2 - 0.5
 
 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},
 ])
 
 #wall thickness t
 t = 0.8
 #line offset from pads o
 o = 0.5
 xo = A/2 + pw/2 + o #horizontal distance from numbered pads
 yo = my - mh/2 - o
 #draw left-hand line
 kicad_mod.addPolygoneLine([
 {'x': -xo,'y': y1},
 {'x': x1,'y': y1},
 {'x': x1,'y': yo},
 {'x': x1+t,'y': yo},

Example #33

kicad_mod = KicadMod(footprint_name)
kicad_mod.setDescription("http://www.jst-mfg.com/product/pdf/eng/ePH.pdf")
kicad_mod.setAttribute('smd')
kicad_mod.setTags('connector jst ph')
kicad_mod.setCenterPos({'x':0, 'y':5.55/2})

# set general values
kicad_mod.addText('reference', 'REF**', {'x':start_pos_x-0.5, 'y':-3-0.225}, 'F.SilkS')
kicad_mod.addText('value', footprint_name, {'x':0, 'y':8.5+0.275}, 'F.Fab')

# create Silkscreen

kicad_mod.addPolygoneLine([{'x':start_pos_x+0.5, 'y':7}
                          ,{'x':start_pos_x+0.5, 'y':6} # 2.75
                          ,{'x':end_pos_x-0.5, 'y':6}
                          ,{'x':end_pos_x-0.5, 'y':7}]
                          ,'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':start_pos_x-0.9, 'y':1}
                          ,{'x':start_pos_x-2.95+0.8, 'y':1}
                          ,{'x':start_pos_x-2.95+0.8, 'y':-0.6}
                          ,{'x':start_pos_x-2.95, 'y':-0.6}
                          ,{'x':start_pos_x-2.95, 'y':3.5}]
                          ,'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}

Example #34

File: connectors_jst_sh_smd_top.py Project: SchrodingersGat/kicad-footprint-generator

kicad_mod = KicadMod(footprint_name)
kicad_mod.setDescription("http://www.jst-mfg.com/product/pdf/eng/eSH.pdf")
kicad_mod.setAttribute('smd')
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}

Example #35

File: ze-top-entry-smd.py Project: SchrodingersGat/kicad-footprint-generator

    createNumberedPadsSMD(kicad_mod, pincount, -pitch, {"x": pw, "y": ph}, py)

    # create some sweet, sweet mechanical pads
    kicad_mod.addMountingPad({"x": mx, "y": my}, {"x": mw, "y": mh})

    kicad_mod.addMountingPad({"x": -mx, "y": my}, {"x": mw, "y": mh})

    # add pin-1 designation

    xm = A / 2 + pw / 2 + 0.5
    ym = py - 0.5

    m = 0.3

    poly = [{"x": xm, "y": ym}, {"x": xm + 2 * m, "y": ym - m}, {"x": xm + 2 * m, "y": ym + m}, {"x": xm, "y": ym}]
    kicad_mod.addPolygoneLine(poly)
    kicad_mod.addPolygoneLine(poly, layer="F.Fab")

    # wall thickness t
    t = 0.8
    # line offset from pads o
    o = 0.5
    xo = A / 2 + pw / 2 + o  # horizontal distance from numbered pads
    yo = my - mh / 2 - o
    # draw left-hand line
    kicad_mod.addPolygoneLine(
        [
            {"x": -xo, "y": y1},
            {"x": x1, "y": y1},
            {"x": x1, "y": yo},
            {"x": x1 + t, "y": yo},

Example #36

File: connectors_multicomp_mc9a12.py Project: SchrodingersGat/kicad-footprint-generator

# 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}
                              ,{'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+7.3+4.1, 'y':1.9}
                              ,{'x':((start_pos_x+end_pos_x)/2)+4.45/2+7.3+4.1, 'y':3.2}], 'F.SilkS', 0.15)

    kicad_mod.addPolygoneLine([{'x':((start_pos_x+end_pos_x)/2)-4.45/2-7.3, 'y':3.2}
                              ,{'x':((start_pos_x+end_pos_x)/2)-4.45/2-7.3, 'y':1.9}

Example #37

File: ezmate_side_smt.py Project: SchrodingersGat/kicad-footprint-generator

 x2 = D/2
 y2 = 2.2
 
 #offset from pads
 xo = 0.4
 
 #offset of angled setction
 ao = 0.5
 
 #add the outline to the F.Fab layer
 kicad_mod.addPolygoneLine([
     {'x': x2, 'y': y2},
     {'x': x2, 'y': y1},
     {'x': x1, 'y': y1},
     {'x': x1, 'y': y2},
     {'x': -A/2, 'y': y2},
     {'x': -A/2 + ao, 'y': y2 - ao},
     {'x': A/2 - ao, 'y': y2 - ao},
     {'x': A/2, 'y': y2},
     {'x': x2, 'y': y2},
     ], 'F.Fab', 0.15
 )
 
 A -= 0.1
 
 #line offset 
 off = 0.15
 
 x1 -= off
 y1 -= off
 
 x2 += off

Example #38

File: SHL_side.py Project: SchrodingersGat/kicad-footprint-generator

    #add mounting pads (no number)
    mpad_w = 1.0
    mpad_h = 2.0
    mpad_x = (B/2) - (mpad_w/2)
    mpad_y = -0.7 - 1.7/2

    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'])

    #offset
    o = 0.15
    
    #add bottom line
    kicad_mod.addPolygoneLine([{'x':-B/2-o,'y':-0.1},
                             {'x':-B/2-o,'y':0.15},
                             {'x':B/2+o,'y':0.15},
                             {'x':B/2+o,'y':-0.1}])
                             
    #add left line
    kicad_mod.addPolygoneLine([{'x':-B/2-o,'y':-3.1},
                                {'x':-B/2-o,'y':-4.45},
                                {'x':-A/2-pad_w/2-0.4,'y':-4.45},
                                {'x':-A/2-pad_w/2-0.4,'y':-5.45}
                                ])

    #add right line
    kicad_mod.addPolygoneLine([{'x':B/2+o,'y':-3.1},
                                {'x':B/2+o,'y':-4.45},
                                {'x':A/2+pad_w/2+0.5,'y':-4.45}])

    #add connector outline to F.Fab

Example #39

File: connectors_jst_gh_smd_top.py Project: andrewjrobinson/kicad-footprint-generator

    #add mounting pads (no number)
    mpad_w = 1.0
    mpad_h = 2.8
    mpad_x = (B/2) - (mpad_w/2)
    mpad_y = -1.4

    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'])

    #side-wall thickness
    T = 0.5
    
    #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},
                            {'x':B/2-mpad_w-0.6,'y':-0.1 - T},
                            {'x':-B/2+mpad_w+0.6,'y':-0.1 - T},
                            {'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.4,'y':-4.4},
                                {'x':-A/2-pad_w/2-0.4,'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}])

    #add right line
    kicad_mod.addPolygoneLine([{'x':B/2+0.1,'y':-3.3},
                                {'x':B/2+0.1,'y':-4.4},

Example #40

File: gh_smd_side.py Project: SchrodingersGat/kicad-footprint-generator

    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}])

    #add right 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},

Example #41

        'y': mpad_h
    }, 0, ['F.Cu', 'F.Paste', 'F.Mask'])

    #side-wall thickness
    T = 0.5

    #add bottom line
    kicad_mod.addPolygoneLine([{
        'x': -B / 2 + mpad_w + 0.6,
        'y': -0.05
    }, {
        'x': B / 2 - mpad_w - 0.6,
        'y': -0.05
    }, {
        'x': B / 2 - mpad_w - 0.6,
        'y': -0.05 + T
    }, {
        'x': -B / 2 + mpad_w + 0.6,
        'y': -0.05 + T
    }, {
        'x': -B / 2 + mpad_w + 0.6,
        'y': -0.05
    }],
                              width=0.12)

    #add left line
    kicad_mod.addPolygoneLine([{
        'x': -B / 2 - 0.1,
        'y': 3.3
    }, {
        'x': -B / 2 - 0.1,

Example #42

File: eh_top_entry_tht.py Project: joonas-lahtinen/kicad-footprint-generator

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

    T = 0.5

    #add top line
    kicad_mod.addPolygoneLine([{
        'x': x1,
        'y': 0
    }, {
        'x': x1 + T,
        'y': 0
    }, {
        'x': x1 + T,
        'y': y1 + T
    }, {
        'x': x2 - T,
        'y': y1 + T
    }, {
        'x': x2 - T,
        'y': 0
    }, {
        'x': x2,
        'y': 0
    }])

    #add bottom line (left)
    kicad_mod.addPolygoneLine([{
        'x': x1,
        'y': y2 - 3 * T
    }, {

Example #43

File: eh_top_entry_tht.py Project: andrewjrobinson/kicad-footprint-generator

    
    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
    
    #add top line
    kicad_mod.addPolygoneLine([{'x': x1,'y': 0},
                               {'x': x1 + T,'y': 0},
                               {'x': x1 + T,'y': y1 + T},
                               {'x': x2 - T,'y': y1 + T},
                               {'x': x2 - T,'y': 0},
                               {'x': x2,'y':0}])

    #add bottom line (left)
    kicad_mod.addPolygoneLine([{'x':x1,'y':y2-3*T},
                               {'x':x1+2*T,'y':y2-3*T},
                               {'x':x1+2*T,'y':y2}])

    #add bottom line (right)
    kicad_mod.addPolygoneLine([{'x':x2,'y':y2-3*T},
                               {'x':x2-2*T,'y':y2-3*T},
                               {'x':x2-2*T,'y':y2}])                               
                               
    #add pin-1 marker
    

Example #44

}, 'F.SilkS')
kicad_mod.addText('value', footprint_name, {
    'x': 0,
    'y': 6.2 + 0.2375
}, 'F.Fab')

# create Silkscreen

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,

Example #45

 
 x1 -= off
 y1 -= off
 
 x2 += off
 y2 += off
 
 
 T = 1.5
 
 y3 = y2 - 2.2
 
 kicad_mod.addPolygoneLine([{'x':x1+T,'y':y3},
                            {'x':x1+T,'y':y2},
                            {'x':x1,'y':y2},
                            {'x':x1,'y':y1},
                            {'x':x2,'y':y1},
                            {'x':x2,'y':y2},
                            {'x':x2-T,'y':y2},
                            {'x':x2-T,'y':y3}], width=0.12)
 
 kicad_mod.addPolygoneLine([{'x':x1,'y':y1+T},
                            {'x':x1+T,'y':y1+T},
                            {'x':x1+T,'y':y3},
                            {'x':x1,'y':y3}], width=0.12)
                            
 kicad_mod.addPolygoneLine([{'x':x2,'y':y1+T},
                        {'x':x2-T,'y':y1+T},
                        {'x':x2-T,'y':y3},
                        {'x':x2,'y':y3}], width=0.12)
                        
 

Example #46

    }, "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
    }, {
        'x': xa,
        'y': y3
    }, {
        'x': xb,
        'y': y3
    }, {
        'x': xb,
        'y': y2
    }])

    #add pin-1 marking above the pin1
    xm = 0
    ym = -1.5

    m = 0.3

    kicad_mod.addPolygoneLine([
        {

Example #47

    }, {
        'x': mpad_w,
        'y': mpad_h
    }, 0, ['F.Cu', 'F.Paste', 'F.Mask'])

    #offset
    o = 0.15

    #add bottom line
    kicad_mod.addPolygoneLine([{
        'x': -B / 2 - o,
        'y': -0.1
    }, {
        'x': -B / 2 - o,
        'y': 0.15
    }, {
        'x': B / 2 + o,
        'y': 0.15
    }, {
        'x': B / 2 + o,
        'y': -0.1
    }],
                              width=0.12)

    #add left line
    kicad_mod.addPolygoneLine([{
        'x': -B / 2 - o,
        'y': -3.1
    }, {
        'x': -B / 2 - o,
        'y': -4.45
    }, {

Example #48

File: ezmate_side_smt.py Project: joonas-lahtinen/kicad-footprint-generator

 kicad_mod.addPolygoneLine([
     {
         'x': x2,
         'y': y2
     },
     {
         'x': x2,
         'y': y1
     },
     {
         'x': x1,
         'y': y1
     },
     {
         'x': x1,
         'y': y2
     },
     {
         'x': -A / 2,
         'y': y2
     },
     {
         'x': -A / 2 + ao,
         'y': y2 - ao
     },
     {
         'x': A / 2 - ao,
         'y': y2 - ao
     },
     {
         'x': A / 2,
         'y': y2
     },
     {
         'x': x2,
         'y': y2
     },
 ], 'F.Fab', 0.15)

Example #49

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

    #add bottom line
    kicad_mod.addPolygoneLine([{
        'x': -B / 2 - 0.1,
        'y': -0.1
    }, {
        'x': -B / 2 - 0.1,
        'y': 0.2
    }, {
        'x': B / 2 + 0.1,
        'y': 0.2
    }, {
        'x': B / 2 + 0.1,
        'y': -0.1
    }])

    #add left line
    kicad_mod.addPolygoneLine([{
        'x': -B / 2 - 0.1,
        'y': -3.1
    }, {
        'x': -B / 2 - 0.1,
        'y': -4.1
    }, {

Example #50

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

    T = 0.5

    #add top line
    kicad_mod.addPolygoneLine([{
        'x': x1,
        'y': 0
    }, {
        'x': x1 + T,
        'y': 0
    }, {
        'x': x1 + T,
        'y': y1 + T
    }, {
        'x': x2 - T,
        'y': y1 + T
    }, {
        'x': x2 - T,
        'y': 0
    }, {
        'x': x2,
        'y': 0
    }])

    #add bottom line (left)
    kicad_mod.addPolygoneLine([{
        'x': x1,
        'y': y2 - 3 * T
    }, {

Example #51

File: connectors_jst_ph_tht_side.py Project: SchrodingersGat/kicad-footprint-generator

# Through-hole type shrouded header, Side entry type
footprint_name = 'JST_PH_S{pincount}B-PH-K_{pincount:02}x2.00mm_Angled'.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':-2.5}, 'F.SilkS')
kicad_mod.addText('value', footprint_name, {'x':(pincount-1)*2/2, 'y':7.5}, 'F.Fab')

# create Silkscreen
kicad_mod.addPolygoneLine([{'x':0.5, 'y':6.25}
                          ,{'x':0.5, 'y':2}
                          ,{'x':(pincount-1)*2-0.5, 'y':2}
                          ,{'x':(pincount-1)*2-0.5, 'y':6.25}]
                          ,'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':-0.9, 'y':0.25}
                          ,{'x':-1.95+0.7, 'y':0.25}
                          ,{'x':-1.95+0.7, 'y':-1.35}
                          ,{'x':-1.95, 'y':-1.35}
                          ,{'x':-1.95, 'y':6.25}
                          ,{'x':(pincount-1)*2+1.95, 'y':6.25}
                          ,{'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

Example #52

    m = 0.3

    poly = [{
        'x': xm,
        'y': ym
    }, {
        'x': xm + 2 * m,
        'y': ym - m
    }, {
        'x': xm + 2 * m,
        'y': ym + m
    }, {
        'x': xm,
        'y': ym
    }]
    kicad_mod.addPolygoneLine(poly, width=0.12)
    kicad_mod.addPolygoneLine(poly, layer='F.Fab', width=0.1)

    #wall thickness t
    t = 0.8
    #line offset from pads o
    o = 0.5
    xo = A / 2 + pw / 2 + o  #horizontal distance from numbered pads
    yo = my - mh / 2 - o
    #draw left-hand line
    kicad_mod.addPolygoneLine([
        {
            'x': -xo,
            'y': y1
        },
        {

Example #53

            'y': y3 - q
        },
                              width=0.12)

        #left side
        if not boss:
            kicad_mod.addPolygoneLine([
                {
                    'x': xa,
                    'y': y3
                },
                {
                    'x': x1 + t,
                    'y': y3
                },
                {
                    'x': x1 + t,
                    'y': y2 - t
                },
                {
                    'x': -1,
                    'y': y2 - t
                },
            ],
                                      width=0.12)
        else:  #boss were declared
            kicad_mod.addLine({
                'x': xa,
                'y': y3
            }, {
                'x': -0.9,

Example #54

File: gh_smd_top.py Project: SchrodingersGat/kicad-footprint-generator

    #add mounting pads (no number)
    mpad_w = 1.0
    mpad_h = 2.8
    mpad_x = (B/2) - (mpad_w/2)
    mpad_y = -1.4

    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'])

    #side-wall thickness
    T = 0.5
    
    #add bottom line
    kicad_mod.addPolygoneLine([{'x':-B/2+mpad_w+0.6,'y':0.05},
                            {'x':B/2-mpad_w-0.6,'y':0.05},
                            {'x':B/2-mpad_w-0.6,'y':0.05 - T},
                            {'x':-B/2+mpad_w+0.6,'y':0.05 - T},
                            {'x':-B/2+mpad_w+0.6,'y':0.05}])
                             
    #add left line
    kicad_mod.addPolygoneLine([{'x':-B/2-0.1,'y':-3.3},
                                {'x':-B/2-0.1,'y':-4.5},
                                {'x':-A/2-pad_w/2-0.4,'y':-4.5},
                                {'x':-A/2-pad_w/2-0.4,'y':-4.5+T},
                                {'x':-B/2-0.1+T,'y':-4.5+T},
                                {'x':-B/2-0.1+T,'y':-3.3},
                                {'x':-B/2-0.1,'y':-3.3}])

    #add right line
    kicad_mod.addPolygoneLine([{'x':B/2+0.1,'y':-3.3},
                                {'x':B/2+0.1,'y':-4.5},

Example #55

File: panelmate_side.py Project: joonas-lahtinen/kicad-footprint-generator

 kicad_mod.addPolygoneLine([
     {
         'x': x2,
         'y': y1
     },
     {
         'x': x1,
         'y': y1
     },
     {
         'x': x1,
         'y': y2
     },
     {
         'x': x1 + t,
         'y': y2
     },
     {
         'x': x1 + t + a,
         'y': y2 - d
     },
     {
         'x': x2 - t - a,
         'y': y2 - d
     },
     {
         'x': x2 - t,
         'y': y2
     },
     {
         'x': x2,
         'y': y2
     },
     {
         'x': x2,
         'y': y1
     },
 ], 'F.Fab', 0.15)

Example #56

File: eh_side_entry_tht.py Project: SchrodingersGat/kicad-footprint-generator

 
 x1 -= off
 y1 -= off
 
 x2 += off
 y2 += off
 
 
 T = 1.5
 
 y3 = y2 - 2.2
 
 kicad_mod.addPolygoneLine([{'x':x1+T,'y':y3},
                            {'x':x1+T,'y':y2},
                            {'x':x1,'y':y2},
                            {'x':x1,'y':y1},
                            {'x':x2,'y':y1},
                            {'x':x2,'y':y2},
                            {'x':x2-T,'y':y2},
                            {'x':x2-T,'y':y3}])
 
 kicad_mod.addPolygoneLine([{'x':x1,'y':y1+T},
                            {'x':x1+T,'y':y1+T},
                            {'x':x1+T,'y':y3},
                            {'x':x1,'y':y3}])
                            
 kicad_mod.addPolygoneLine([{'x':x2,'y':y1+T},
                        {'x':x2-T,'y':y1+T},
                        {'x':x2-T,'y':y3},
                        {'x':x2,'y':y3}])