kicad-developers team mailing list archive

[easyw <easyw@xxxxxxxxxxxx>]

Hi,

I attached a patch for exposed pad on qfp_wizard.
There is one exposed pad not on solder paste (but on solder mask) + one 
array of pads on solder paste.
the same pad name for all of them, and pads optional in wizard 
(assigning epad subdivision to 0 epad array won't be generated;
 assigning epad width or lenght to 0, epad  won't be generated).

Could please someone tells me if there is something to change or wrong 
in that ...
it seems not to be considered / committed

PS I changeg the subject because it is not related only to windows but 
is fine for linux and osx too.

than you
Maurice

On 30/08/2015 20.27, jp charras wrote:
> Le 30/08/2015 19:21, nnn a écrit :
> > It may be better to make exposed pad as array of smaller pads for better
> > application of solder paste. This will also allow to easily change the
> > pad into array of tht pads for improved power dissipation. Below - how I
> > did it in C (full code here:
> > https://github.com/michal777/KiCad_Footprint_Generator). I think exposed
> > pad should be numbered max+1 because sometimes there are more exposed pads.
>
> Exactly one exposed pad not on solder paste (but on solder mask) + this
> array of pads on solder paste.
>
> Keep the same pad name for all of them, and make them optional in wizard.

--- qfp_wizard-old.py	2015-09-03 15:04:44.826058400 +0200
+++ qfp_wizard.py	2015-09-03 15:13:51.682393300 +0200
@@ -24,22 +24,29 @@
 class QFPWizard(HelpfulFootprintWizardPlugin.HelpfulFootprintWizardPlugin):

     def GetName(self):
-        return "QFP"
+        return "QFP/QFN"

     def GetDescription(self):
-        return "QFP Footprint Wizard"
+        return "QFP/QFN Footprint Wizard"

     def GenerateParameterList(self):
-        self.AddParam("Pads", "n", self.uNatural, 100)
+
+        self.AddParam("Pads", "n", self.uNatural, 64)
         self.AddParam("Pads", "pad pitch", self.uMM, 0.5)
-        self.AddParam("Pads", "pad width", self.uMM, 0.25)
-        self.AddParam("Pads", "pad length", self.uMM, 1.5)
-        self.AddParam("Pads", "vertical pitch", self.uMM, 15)
-        self.AddParam("Pads", "horizontal pitch", self.uMM, 15)
-        self.AddParam("Pads", "oval", self.uBool, True)
+        self.AddParam("Pads", "pad width", self.uMM, 0.3)
+        self.AddParam("Pads", "pad length", self.uMM, 0.9)
+        self.AddParam("Pads", "vertical pitch", self.uMM, 8.9)
+        self.AddParam("Pads", "horizontal pitch", self.uMM, 8.9)
+        self.AddParam("Pads", "oval", self.uBool, False)
+        self.AddParam("Pads", "package width", self.uMM, 9)
+        self.AddParam("Pads", "package height", self.uMM, 9)
+        self.AddParam("Pads", "epad width", self.uMM, 7.5)
+        self.AddParam("Pads", "epad length", self.uMM, 7.5)
+        self.AddParam("Pads", "epad subdivision h", self.uNatural, 2)
+        self.AddParam("Pads", "epad subdivision v", self.uNatural, 2)
+        self.AddParam("Pads", "Name prefix QFP/QFN", self.uString, 'QFN')
+        self.AddParam("Pads", "epad solder paste ratio", self.uNatural, 0.8)

-        self.AddParam("Pads", "package width", self.uMM, 14)
-        self.AddParam("Pads", "package height", self.uMM, 14)

     def CheckParameters(self):

@@ -47,16 +54,24 @@
         self.CheckParamBool("Pads", "*oval")

     def GetValue(self):
-        return "QFP_%d" % self.parameters["Pads"]["*n"]
+        return "%s_%d" % (self.parameters["Pads"]["*Name prefix QFP/QFN"], self.parameters["Pads"]["*n"])

     def BuildThisFootprint(self):

         pads = self.parameters["Pads"]

+        module_prefix = pads["*Name prefix QFP/QFN"]
         pad_pitch = pads["pad pitch"]
         pad_length = self.parameters["Pads"]["pad length"]
         pad_width = self.parameters["Pads"]["pad width"]

+        epad_length = self.parameters["Pads"]["epad length"]
+        epad_width = self.parameters["Pads"]["epad width"]
+        epad_subd_l = pads["*epad subdivision h"]
+        epad_subd_w = pads["*epad subdivision v"]
+
+        epad_paste_ratio = pads["*epad solder paste ratio"]
+
         v_pitch = pads["vertical pitch"]
         h_pitch = pads["horizontal pitch"]

@@ -99,6 +114,29 @@
         array.SetFirstPadInArray(3*pads_per_row + 1)
         array.AddPadsToModule(self.draw)

+        #epad
+        if epad_length!=0 and epad_width!=0:  #there is exposed pad
+            e_pad = PA.PadMaker(self.module).SMDePad(
+            epad_width, epad_length, shape=pcbnew.PAD_SHAPE_RECT)
+            epadPos = pcbnew.wxPoint (0, 0)
+            array = PA.PadLineArray(e_pad, 1, 1, False,
+                                    epadPos)
+            array.SetFirstPadInArray(pads["*n"]+1)
+            array.AddPadsToModule(self.draw)
+
+            if epad_subd_l!=0 and epad_subd_w!=0:
+            #if we want epad
+                epad_width_part_size_w = epad_width / epad_subd_w  #size of one part of exposed pad
+                epad_width_part_size_l = epad_length / epad_subd_l
+                epad_paste = PA.PadMaker(self.module).SMDPad(
+                epad_width_part_size_w*epad_paste_ratio, epad_width_part_size_l*epad_paste_ratio, shape=pcbnew.PAD_SHAPE_RECT)
+
+                array_epad = PA.PadThermalArray(epad_paste, epad_subd_l, epad_subd_w,
+                                    epad_width_part_size_l, epad_width_part_size_w, epadPos)
+
+                array_epad.SetFirstPadInArray(pads["*n"]+1)
+                array_epad.AddPadsToModule(self.draw)
+
         lim_x = pads["package width"] / 2
         lim_y = pads["package height"] / 2
         inner = (row_len / 2) + pad_pitch
--- PadArray-old.py	2015-09-03 15:04:38.426732100 +0200
+++ PadArray.py	2015-09-03 14:02:17.346140600 +0200
@@ -76,6 +76,16 @@
         pad = self.SMDPad(size, size, shape=pcbnew.PAD_SHAPE_CIRCLE)
         return pad

+    def SMDePad(self, w, l, shape=pcbnew.PAD_SHAPE_RECT):
+        pad = pcbnew.D_PAD(self.module)
+        pad.SetSize(pcbnew.wxSize(l, w))
+
+        pad.SetShape(shape)
+
+        pad.SetAttribute(pcbnew.PAD_ATTRIB_SMD)
+        pad.SetLayerSet(pad.ConnSMDMask())
+
+        return pad

 class PadArray:

@@ -257,3 +267,44 @@
             pad.SetPadName(self.GetName(i))

             self.AddPad(pad)
+
+
+
+class PadThermalArray(PadArray):
+
+    def __init__(self, pad, nx, ny, px, py, centre=pcbnew.wxPoint(0, 0)):
+        PadArray.__init__(self)
+        # this pad is more of a "context", we will use it as a source of
+        # pad data, but not actually add it
+        self.pad = pad
+        self.nx = int(nx)
+        self.ny = int(ny)
+        self.px = px
+        self.py = py
+        self.centre = centre
+
+    # right to left, top to bottom
+    def NamingFunction(self, x, y):
+        return self.firstPadNum
+
+    #relocate the pad and add it as many times as we need
+    def AddPadsToModule(self, dc):
+
+        pin1posX = self.centre.x - self.px * (self.nx - 1) / 2
+        pin1posY = self.centre.y - self.py * (self.ny - 1) / 2
+
+        for x in range(0, self.nx):
+
+            posX = pin1posX + (x * self.px)
+
+            for y in range(self.ny):
+                posY = pin1posY + (self.py * y)
+
+                pos = dc.TransformPoint(posX, posY)
+
+                pad = self.GetPad(x == 0 and y == 0, pos)
+
+                pad.SetPadName(self.GetName(x,y))
+
+                self.AddPad(pad)
+