Python KicadMod.addLine Beispiele

Beispiel #1

Datei: connectors_jst_ph_tht_top.py Projekt: joonas-lahtinen/kicad-footprint-generator

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

Beispiel #2

                },
                {
                    '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,
                'y': y3
            },
                              width=0.12)

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

Beispiel #3

Datei: connectors_jst_sh_smd_side.py Projekt: SchrodingersGat/kicad-footprint-generator

# SMT type shrouded header, Top entry type
footprint_name = 'JST_SH_SM{pincount:02g}B-SRSS-TB_{pincount:02g}x1.00mm_Angled'.format(pincount=pincount)

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)

Beispiel #4

     '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.addLine({'x':x1,'y':y1},{'x':-A/2-q,'y':y1})
 kicad_mod.addLine({'x':x2,'y':y1},{'x':A/2+q,'y':y1})
 
 #draw the side lines
 kicad_mod.addLine({'x':x1,'y':y1},{'x':x1,'y':0.3})
 kicad_mod.addLine({'x':x2,'y':y1},{'x':x2,'y':0.3})
 
 #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

Beispiel #5

Datei: connectors_multicomp_mc9a12.py Projekt: zhdjet/kicad-footprint-generator

    'x': end_pos_x / 2 - 0.25,
    'y': -pad_spacing - 3.2
}, {
    'x': end_pos_x / 2 - 0.25,
    'y': -pad_spacing - 3.2 - 0.2
}, {
    'x': end_pos_x / 2 + 0.25,
    'y': -pad_spacing - 3.2 - 0.2
}, {
    'x': end_pos_x / 2 + 0.25,
    'y': -pad_spacing - 3.2
}], 'F.SilkS', 0.15)
kicad_mod.addLine({
    'x': end_pos_x / 2 - 0.25,
    'y': -pad_spacing - 3.2 - 0.1
}, {
    'x': end_pos_x / 2 + 0.25,
    'y': -pad_spacing - 3.2 - 0.1
}, 'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{
    'x': end_pos_x + 2.4 - 0.25,
    'y': -pad_spacing - 3.2
}, {
    'x': end_pos_x + 2.4 - 0.25,
    'y': -pad_spacing - 3.2 - 0.2
}, {
    'x': end_pos_x + 2.4 + 0.25,
    'y': -pad_spacing - 3.2 - 0.2
}, {
    'x': end_pos_x + 2.4 + 0.25,

Beispiel #6

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

Beispiel #7

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

    #right hand wall
    kicad_mod.addLine({'x': xb, 'y': y2 - b}, {'x': xb, 'y': y2})

    #add a "slot" for each of the pins
    for i in range(pincount):
        x = -A / 2 + i * pitch

        #width of each pin
        w = 0.15

        ya = py + ph / 2 + 0.6
        yb = y2 - b - 0.5

        kicad_mod.addRectLine({'x': x - w, 'y': ya}, {'x': x + w, 'y': yb})

Beispiel #8

Datei: connectors_jst_ph_smd_top.py Projekt: SchrodingersGat/kicad-footprint-generator

                          ,{'x':start_pos_x-1.2, 'y':2.3}
                          ,{'x':start_pos_x-0.9, 'y':2.3}] 
                          ,'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':end_pos_x-0.5, 'y':-1.9}
                          ,{'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'])

Beispiel #9

Datei: ze-top-entry-tht.py Projekt: SchrodingersGat/kicad-footprint-generator

 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
 
 if pincount %2 == 0: #even number of pins
     xEnd = (pincount / 2 - 1) * (2 * pitch) + 1
 else:
     xEnd = floor(pincount / 2) * (2 * pitch) + 1
 
 kicad_mod.addPolygoneLine([

Beispiel #10

Datei: connectors_jst_ph_tht_top.py Projekt: SchrodingersGat/kicad-footprint-generator

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)

for i in range(0, pincount-1):
    middle_x = 1+i*2
    start_x = middle_x-0.1
    end_x = middle_x+0.1

Beispiel #11

Datei: eh_side_entry_tht.py Projekt: andrewjrobinson/kicad-footprint-generator

 kicad_mod.addPolygoneLine([{'x':x2,'y':y1+T},
                        {'x':x2-T,'y':y1+T},
                        {'x':x2-T,'y':y3},
                        {'x':x2,'y':y3}])
                        
 
 
 #add pictures of pins
 #pin-width w
 #pin-length l
 w = 0.32
 l = 3.5
 
 py = -2.5
 
 kicad_mod.addLine({'x':x1+T,'y':py},{'x':x2-T,'y':py})
 
 kicad_mod.addLine({'x':x1+T,'y':py+1},{'x':x2-T,'y':py+1})
 
 for p in range(pincount):
     
     px = p * pitch
     
     kicad_mod.addPolygoneLine([{'x': px,'y': py},
                                {'x': px-w,'y': py},
                                {'x': px-w,'y': py-l+0.25*w},
                                {'x': px,'y': py-l},
                                {'x': px+w,'y': py-l+0.25*w},
                                {'x': px+w,'y': py},
                                {'x': px,'y': py}])
 

Beispiel #12

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

Beispiel #13

Datei: connectors_multicomp_mc9a22.py Projekt: zhdjet/kicad-footprint-generator

                          ,{'x':start_pos_x-1, 'y':-12.5}], 'F.SilkS', 0.15)

# create Courtyard
def round_to(n, precision):
    correction = 0.5 if n >= 0 else -0.5
    return int( n/precision+correction ) * precision

kicad_mod.addRectLine({'x':round_to(start_pos_x-3.87-1.2-0.5,0.05), 'y':1.7/2+0.5}, {'x':round_to(end_pos_x+3.87+1.2+0.5,0.05), 'y':round_to(-pad_spacing-1.8-8.9-0.5,0.05)}, 'F.CrtYd', 0.05)

# create pads
pad_diameter = 1
pad_size = {'x':1.7, 'y':1.7}

for pad_number in range(1, pincount, 2):
    pad_pos_x = (pad_number-1)/2*pad_spacing
    if pad_number == 1:
        kicad_mod.addPad(pad_number, 'thru_hole', 'rect', {'x':pad_pos_x, 'y':0}, pad_size, pad_diameter, ['*.Cu', '*.Mask', 'F.SilkS'])
    else:
        kicad_mod.addPad(pad_number, 'thru_hole', 'circle', {'x':pad_pos_x, 'y':0}, pad_size, pad_diameter, ['*.Cu', '*.Mask', 'F.SilkS'])

    kicad_mod.addPad(pad_number+1, 'thru_hole', 'circle', {'x':pad_pos_x, 'y':-pad_spacing}, pad_size, pad_diameter, ['*.Cu', '*.Mask', 'F.SilkS'])
    
    kicad_mod.addLine({'x':pad_pos_x-0.4, 'y':-1.1}, {'x':pad_pos_x-0.4, 'y':-pad_spacing+1.1}, 'F.SilkS', 0.15)
    kicad_mod.addLine({'x':pad_pos_x+0.4, 'y':-1.1}, {'x':pad_pos_x+0.4, 'y':-pad_spacing+1.1}, 'F.SilkS', 0.15)
    
    kicad_mod.addLine({'x':pad_pos_x-0.4, 'y':-pad_spacing-1.1}, {'x':pad_pos_x-0.4, 'y':-pad_spacing-1.8}, 'F.SilkS', 0.15)
    kicad_mod.addLine({'x':pad_pos_x+0.4, 'y':-pad_spacing-1.1}, {'x':pad_pos_x+0.4, 'y':-pad_spacing-1.8}, 'F.SilkS', 0.15)

# output kicad model
print(kicad_mod)

Beispiel #14

        'x': x2,
        'y': y1
    }, {
        'x': x2,
        'y': y2
    }, {
        'x': (pincount - 1 + 0.2) * pitch,
        'y': y2
    }, {
        'x': (pincount - 1 + 0.2) * pitch,
        'y': y2 - o
    }])

    #line across the middle
    py = -2.5
    kicad_mod.addLine({'x': x1 + w, 'y': py}, {'x': x2 - w, 'y': py})
    kicad_mod.addLine({
        'x': x1 + w,
        'y': py + 1.5
    }, {
        'x': x2 - w,
        'y': py + 1.5
    })

    kicad_mod.addLine({'x': x1 + w, 'y': y1}, {'x': x1 + w, 'y': y2})
    kicad_mod.addLine({'x': x2 - w, 'y': y1}, {'x': x2 - w, 'y': y2})
    #add picture of pins

    #add pictures of pins
    #pin-width w
    #pin-length l

Beispiel #15

        'x': x2 - T,
        'y': y3
    }, {
        'x': x2,
        'y': y3
    }])

    #add pictures of pins
    #pin-width w
    #pin-length l
    w = 0.32
    l = 3.5

    py = -2.5

    kicad_mod.addLine({'x': x1 + T, 'y': py}, {'x': x2 - T, 'y': py})

    kicad_mod.addLine({'x': x1 + T, 'y': py + 1}, {'x': x2 - T, 'y': py + 1})

    for p in range(pincount):

        px = p * pitch

        kicad_mod.addPolygoneLine([{
            'x': px,
            'y': py
        }, {
            'x': px - w,
            'y': py
        }, {
            'x': px - w,

Beispiel #16

Datei: ze-top-entry-smd.py Projekt: andrewjrobinson/kicad-footprint-generator

 
 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}
 )
 
 #right hand wall
 kicad_mod.addLine(
 {'x':  xb,'y': y2-b},
 {'x':  xb,'y': y2}
 )
 
 #add a "slot" for each of the pins
 for i in range(pincount):
     x = -A/2 + i * pitch
     
     #width of each pin
     w = 0.15
     

Beispiel #17

        '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

Beispiel #18

Datei: connectors_jst_sh_smd_top.py Projekt: SchrodingersGat/kicad-footprint-generator

# SMT type shrouded header, Top entry type
footprint_name = 'JST_SH_BM{pincount:02g}B-SRSS-TB_{pincount:02g}x1.00mm_Straight'.format(pincount=pincount)

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)

Beispiel #19

Datei: ze-top-entry-smd.py Projekt: SchrodingersGat/kicad-footprint-generator

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

    # right hand wall
    kicad_mod.addLine({"x": xb, "y": y2 - b}, {"x": xb, "y": y2})

    # add a "slot" for each of the pins
    for i in range(pincount):
        x = -A / 2 + i * pitch

        # width of each pin
        w = 0.15

        ya = py + ph / 2 + 0.6
        yb = y2 - b - 0.5

        kicad_mod.addRectLine({"x": x - w, "y": ya}, {"x": x + w, "y": yb})

Beispiel #20

Datei: connectors_multicomp_mc9a12.py Projekt: SchrodingersGat/kicad-footprint-generator

    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}
                              ,{'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)
    
    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}
                              ,{'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)

# lines above the footprint
kicad_mod.addPolygoneLine([{'x':end_pos_x/2-0.25, 'y':-pad_spacing-3.2}
                          ,{'x':end_pos_x/2-0.25, 'y':-pad_spacing-3.2-0.2}
                          ,{'x':end_pos_x/2+0.25, 'y':-pad_spacing-3.2-0.2}
                          ,{'x':end_pos_x/2+0.25, 'y':-pad_spacing-3.2}], 'F.SilkS', 0.15)
kicad_mod.addLine({'x':end_pos_x/2-0.25, 'y':-pad_spacing-3.2-0.1}, {'x':end_pos_x/2+0.25, 'y':-pad_spacing-3.2-0.1}, 'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':end_pos_x+2.4-0.25, 'y':-pad_spacing-3.2}
                          ,{'x':end_pos_x+2.4-0.25, 'y':-pad_spacing-3.2-0.2}
                          ,{'x':end_pos_x+2.4+0.25, 'y':-pad_spacing-3.2-0.2}
                          ,{'x':end_pos_x+2.4+0.25, 'y':-pad_spacing-3.2}], 'F.SilkS', 0.15)
kicad_mod.addLine({'x':end_pos_x+2.4-0.25, 'y':-pad_spacing-3.2-0.1}, {'x':end_pos_x+2.4+0.25, 'y':-pad_spacing-3.2-0.1}, 'F.SilkS', 0.15)

kicad_mod.addPolygoneLine([{'x':start_pos_x-2.4-0.25, 'y':-pad_spacing-3.2}
                          ,{'x':start_pos_x-2.4-0.25, 'y':-pad_spacing-3.2-0.2}
                          ,{'x':start_pos_x-2.4+0.25, 'y':-pad_spacing-3.2-0.2}
                          ,{'x':start_pos_x-2.4+0.25, 'y':-pad_spacing-3.2}], 'F.SilkS', 0.15)
kicad_mod.addLine({'x':start_pos_x-2.4-0.25, 'y':-pad_spacing-3.2-0.1}, {'x':start_pos_x-2.4+0.25, 'y':-pad_spacing-3.2-0.1}, 'F.SilkS', 0.15)

# triangle which is pointing at 1
kicad_mod.addPolygoneLine([{'x':start_pos_x-2.2, 'y':0.6}

Beispiel #21

Datei: connectors_jst_ph_smd_top.py Projekt: joonas-lahtinen/kicad-footprint-generator

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

Beispiel #22

# 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
}, {

Beispiel #23

 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)
                        
 
 
 #add pictures of pins
 #pin-width w
 #pin-length l
 w = 0.32
 l = 3.5
 
 py = -2.5
 
 kicad_mod.addLine({'x':x1+T,'y':py},{'x':x2-T,'y':py}, width=0.12)
 
 kicad_mod.addLine({'x':x1+T,'y':py+1},{'x':x2-T,'y':py+1}, width=0.12)
 
 for p in range(pincount):
     
     px = p * pitch
     
     kicad_mod.addPolygoneLine([{'x': px,'y': py},
                                {'x': px-w,'y': py},
                                {'x': px-w,'y': py-l+0.25*w},
                                {'x': px,'y': py-l},
                                {'x': px+w,'y': py-l+0.25*w},
                                {'x': px+w,'y': py},
                                {'x': px,'y': py}], width=0.12)
 

Beispiel #24

                          width=0.12)

    #inner rect
    #rect thickness r
    r = 0.4
    kicad_mod.addRectLine({
        'x': xa + r,
        'y': y2 - b + r
    }, {
        'x': xb - r,
        'y': y2 - r
    },
                          width=0.12)

    #left hand wall
    kicad_mod.addLine({'x': xa, 'y': y2 - b}, {'x': xa, 'y': y2}, width=0.12)

    #right hand wall
    kicad_mod.addLine({'x': xb, 'y': y2 - b}, {'x': xb, 'y': y2}, width=0.12)

    #add a "slot" for each of the pins
    for i in range(pincount):
        x = -A / 2 + i * pitch

        #width of each pin
        w = 0.15

        ya = py + ph / 2 + 0.6
        yb = y2 - b - 0.75

        kicad_mod.addRectLine({

Beispiel #25

Datei: connectors_jst_ph_tht_side.py Projekt: SchrodingersGat/kicad-footprint-generator

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

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)

Beispiel #26

Datei: connectors_molex_kk_6410_top.py Projekt: SchrodingersGat/kicad-footprint-generator

# 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}
                              ,{'x':start_pos_x+2*pad_spacing, 'y':1.55}
                              ,{'x':start_pos_x+2*pad_spacing, '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':start_pos_x+2*pad_spacing-0.25, 'y':2.98}, {'x':start_pos_x+2*pad_spacing-0.25, 'y':1.98}, 'F.SilkS', 0.15)
    
    kicad_mod.addPolygoneLine([{'x':end_pos_x, 'y':2.98}

Beispiel #27

Datei: ze-top-entry-tht.py Projekt: andrewjrobinson/kicad-footprint-generator

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

Beispiel #28

Datei: df13_angled_pth.py Projekt: andrewjrobinson/kicad-footprint-generator

  #outline size o
  o = 0.15
  
  #draw the main outline around the footprint
  kicad_mod.addPolygoneLine([{'x':-0.2*pitch,'y':y2-o},
                             {'x':-0.2*pitch,'y':y2},
                             {'x':x1,'y':y2},
                             {'x':x1,'y':y1},
                             {'x':x2,'y':y1},
                             {'x':x2,'y':y2},
                             {'x':(pincount -1 + 0.2) * pitch,'y':y2},
                             {'x':(pincount -1 + 0.2) * pitch,'y':y2-o}])
                             
  #line across the middle
  py = -2.5
  kicad_mod.addLine({'x':x1+w,'y':py},{'x':x2-w,'y':py})
  kicad_mod.addLine({'x':x1+w,'y':py+1.5},{'x':x2-w,'y':py+1.5})
  
  kicad_mod.addLine({'x':x1+w,'y':y1},{'x':x1+w,'y':y2})
  kicad_mod.addLine({'x':x2-w,'y':y1},{'x':x2-w,'y':y2})
  #add picture of pins
  
   #add pictures of pins
  #pin-width w
  #pin-length l
  w = 0.15
  l = 1.5
 
  for p in range(pincount):
      
      px = p * pitch