spiki.py

#!/usr/bin/env python

# Licensed under GNU GPL version 2 or later

import sys
import math

useNLopt = True
try:  # check if nlopt is available
    import nlopt
except ImportError:
    useNLopt = False

if (useNLopt):
    from numpy import *  # needed by nlopt

from PyQt6 import QtGui, QtWidgets, uic
from PyQt6.QtCore import Qt, QThread
from PyQt6.QtWidgets import QApplication, QFileDialog, QMessageBox

import dos

Ui_MainWindow, QtBaseClass = uic.loadUiType("design.ui")

class SuperEnum(object):
    class __metaclass__(type):
        def __iter__(self):
            for item in self.__dict__:
                if item == self.__dict__[item]:
                    yield item
                    
class InductorStyle(SuperEnum):
    CIRCULAR_SEGMENTS = 0
    CIRCULAR_ARCS = 1
    SQUARE = 2

class kSpiralCalc(QtBaseClass, Ui_MainWindow):

    def __init__(self):
        super(self.__class__, self).__init__()
        self.setupUi(self)

        # File
        self.actionExit.triggered.connect(QApplication.quit)
        self.actionSave_module.triggered.connect(self.writeModule)

        # add validators to LineEdits
        dGt0Val = QtGui.QDoubleValidator() # a double...
        dGt0Val.setBottom(0.0) # ...greater than zero
        self.nTurnsLineEdit.setValidator(dGt0Val)
        self.innerRadiusLineEdit.setValidator(dGt0Val)
        self.pitchLineEdit.setValidator(dGt0Val)
        self.spacingLineEdit.setValidator(dGt0Val)
        self.traceWidthLineEdit.setValidator(dGt0Val)

        self.freqLineEdit.setValidator(dGt0Val)

        self.pcbThicknessLineEdit.setValidator(dGt0Val)
        self.cuThicknessLineEdit.setValidator(dGt0Val)
        self.minSpacingLineEdit.setValidator(dGt0Val)

        self.drawTolLineEdit.setValidator(dGt0Val)

        iGt1Val = QtGui.QIntValidator() # an integer...
        iGt1Val.setBottom(1) # ...greater than 1
        self.nLayersLineEdit.setValidator(iGt1Val)

        # some default values
        self.nTurnsLineEdit.setText('13')
        self.innerRadiusLineEdit.setText('5')
        self.pitchLineEdit.setText('3')
        self.spacingLineEdit.setText('1')
        self.traceWidthLineEdit.setText('2')
        self.cuThicknessLineEdit.setText('35')
        self.pcbThicknessLineEdit.setText('1.6')
        self.nLayersLineEdit.setText('1')

        self.freqLineEdit.textChanged.connect(self.updateSkinDepth)
        self.freqLineEdit.setText('1.0')

        self.minSpacingLineEdit.setText('0.15')

        self.drawTolLineEdit.setText('0.1')
        self.polygonVertexCountLineEdit.setText('4')
        self.setPolygonVertexCountSettingVisible(False)

        self.nTurnsLineEdit.textChanged.connect(self.estimateInductance)
        self.innerRadiusLineEdit.textChanged.connect(self.estimateInductance)
        self.pitchLineEdit.textChanged.connect(self.estimateInductance)
        self.spacingLineEdit.textChanged.connect(self.estimateInductance)
        self.traceWidthLineEdit.textChanged.connect(self.estimateInductance)
        self.nLayersLineEdit.textChanged.connect(self.estimateInductance)
        
        self.indStyleCB.activated.connect(self.inductorStyleChanged)

        self.estimateInductance()

        self.pitchLineEdit.textChanged.connect(self.updateSpacing)
        # if trace width is changed keep pitch constant and update the
        # resulting spacing
        self.traceWidthLineEdit.textChanged.connect(self.updateSpacing)
        self.spacingLineEdit.textChanged.connect(self.updatePitch)

        self.runSimBtn.clicked.connect(self.runSimulation)
        self.optimizeBtn.clicked.connect(self.runOptimization)
        if (not useNLopt):
            self.optimizeBtn.setEnabled(False)  # disable optimization button

        self.statusBar().showMessage("Ready.")
        
    def showInvalidParametersErrorMsg(self):
        msg = QMessageBox()
        msg.setIcon(QMessageBox.Critical)
        msg.setText('It is physically impossible to produce an inductor from the given inductor parameters')
        msg.setInformativeText('Please adjust one or more of the inductor parameters and try again')
        msg.setWindowTitle("Error")
        msg.exec()
        
    def inductorStyleChanged(self, index):
        if (index == InductorStyle.SQUARE):
            self.setPolygonVertexCountSettingVisible(False)
            
            self.nLayersLabel.setVisible(False)
            self.nLayersLineEdit.setText('1')
            self.nLayersLineEdit.setVisible(False)

            self.innerRadiusLabel.setText('edge length')
        
        if (index == InductorStyle.CIRCULAR_SEGMENTS):
            self.setPolygonVertexCountSettingVisible(False)
            
        if (index == InductorStyle.CIRCULAR_ARCS):
            self.setPolygonVertexCountSettingVisible(True)
            
        if ((index == InductorStyle.CIRCULAR_SEGMENTS) or (index == InductorStyle.CIRCULAR_ARCS)):
            self.nLayersLabel.setVisible(True)
            self.nLayersLineEdit.setVisible(True)
            self.innerRadiusLabel.setText('inner radius')
        
    def setPolygonVertexCountSettingVisible(self, val):
        self.polygonVertexCountLabel.setVisible(val)
        self.polygonVertexCountLineEdit.setVisible(val)

    def updateSpacing(self):
        pitch = float(self.pitchLineEdit.text())
        traceWidth = float(self.traceWidthLineEdit.text())
        spacing = pitch - traceWidth
        self.spacingLineEdit.blockSignals(True)
        self.spacingLineEdit.setText(str(spacing))
        self.spacingLineEdit.blockSignals(False)

    def updatePitch(self):
        spacing = float(self.spacingLineEdit.text())
        traceWidth = float(self.traceWidthLineEdit.text())
        pitch = spacing + traceWidth
        self.pitchLineEdit.blockSignals(True)
        self.pitchLineEdit.setText(str(pitch))
        self.pitchLineEdit.blockSignals(False)

    def updateSkinDepth(self):
        freq = float(self.freqLineEdit.text()) * 1e6
        sigma = 5.8e7 # copper conductivity
        mur = 0.999994 # relative magnetic permeability of copper
        mu0 = 4.0e-7 * math.pi # the permeability of free space
        mu = mur * mu0 # permeability of a given conductor,
        self.delta = 1.0 / math.sqrt(math.pi * freq * mu * sigma)  # in meters
        self.skinDepthLineEdit.setText(str(self.delta * 1e3))

    def runSimulation(self):
        self.statusBar().showMessage("Simulating...")
        # update GUI to show changes status bar message
        QApplication.processEvents()
        self.simulate()
        self.statusBar().showMessage("Ready.")

    def simulate(self):
        nTurns = float(self.nTurnsLineEdit.text())
        innerRadius = float(self.innerRadiusLineEdit.text())
        pitch = float(self.pitchLineEdit.text())
        spacing = float(self.spacingLineEdit.text())
        traceWidth = float(self.traceWidthLineEdit.text())
        cuThickness = float(self.cuThicknessLineEdit.text())
        pcbThickness = float(self.pcbThicknessLineEdit.text())
        nLayers = int(self.nLayersLineEdit.text())
        freq = float(self.freqLineEdit.text())
        d = float(self.drawTolLineEdit.text())

        # compute smaller filament size (see fasthenry docs)
        nw = 2  # fasthenry default
        nh = 2  # fasthenry default

        nwinc = 1  # needs to be odd
        while True:
            n = (nwinc - 1) / 2  # rounding down
            nfils = (2.0 - nw**n * (1.0 + nw)) / (1 - nw)
            fw = 1e-3 * traceWidth / nfils  # smaller width filament size
            if (fw < self.delta):
                break
            nwinc = nwinc + 2

        nhinc = 1  # needs to be odd
        while True:
            n = (nhinc - 1) / 2  # rounding down
            nfils = (2.0 - nh**n * (1.0 + nh)) / (1 - nh)
            fh = 1e-6 * cuThickness / nfils  # smaller height filament
            if (fh < self.delta):
                break
            nhinc = nhinc + 2

        # print 'nwinc =', nwinc
        # print 'nhinc =', nhinc

        sf = dos.fh_file('test.inp')
        sf.write_header(nwinc, nhinc)
        #draw_arcs_spiral(N_turns, r_in, pitch, tr_w, N, dir)
        dir = 1

        inductorStyleIndex = self.indStyleCB.currentIndex()
        if (inductorStyleIndex == InductorStyle.SQUARE):
            vx = dos.square_spiral(nTurns, innerRadius, pitch)
        else:
            vx = dos.circ_spiral(nTurns, innerRadius, pitch, dir, d)

        sf.add_circ_spiral(vx, 1, traceWidth, cuThickness * 1e-3, pcbThickness)
        sf.add_ports()
        if (nLayers == 2):
            vx = dos.circ_spiral(nTurns, innerRadius, pitch, -dir, d)
            sf.add_circ_spiral(
                vx,
                2,
                traceWidth,
                cuThickness * 1e-3,
                pcbThickness)
            sf.add_ports()

        sf.add_frequency(freq * 1e6)
        sf.close()
        sf.run()

        freqs, mats = sf.readZc()

        if (nLayers == 1):
            Xs = mats[0][0][0].imag
            Rs = mats[0][0][0].real
        else:
            Zs1 = mats[0][0][0]
            Zs2 = mats[0][1][1]
            M1 = mats[0][0][1]
            M2 = mats[0][1][0]
            # inductors in series, aiding; minus sign due to coils ports order
            Zs = Zs1 + Zs2 - (M1 + M2)
            Xs = Zs.imag
            Rs = Zs.real

        Ls = 1e6 * Xs / (2.0 * math.pi * freqs[0])  # uH
        Q = Xs / Rs

        self.simIndLineEdit.setText("%.3e" % Ls)
        self.simResLineEdit.setText("%.3e" % Rs)
        self.simQLineEdit.setText("%.1e" % Q)

        return Ls

    def runOptimization(self):
        self.statusBar().showMessage("Optimizing...")
        # update GUI to show changes status bar message
        QtGui.QApplication.processEvents()

        nTurns = float(self.nTurnsLineEdit.text())
        innerRadius = float(self.innerRadiusLineEdit.text())
        pitch = float(self.pitchLineEdit.text())
        spacing = float(self.spacingLineEdit.text())
        traceWidth = float(self.traceWidthLineEdit.text())
        cuThickness = float(self.cuThicknessLineEdit.text())
        pcbThickness = float(self.pcbThicknessLineEdit.text())

        targetInd = float(self.desiredIndLineEdit.text())

        def errfunc(x, grad):
            if grad.size > 0:
                grad = Null
            self.spacingLineEdit.setText(str(x[0]))
            QtGui.QApplication.processEvents()  # update GUI
            ind = self.simulate()
            err = math.fabs(ind - targetInd)
            return err

        opt = nlopt.opt(nlopt.LN_COBYLA, 1)
        minSpacing = float(self.minSpacingLineEdit.text())
        opt.set_lower_bounds([minSpacing])
        opt.set_min_objective(errfunc)
        opt.set_xtol_rel(1e-2)
        x = opt.optimize([spacing])
        minf = opt.last_optimum_value()
        print("optimum at ", x[0])
        print("minimum value = ", minf)
        print("result code = ", opt.last_optimize_result())

        self.spacingLineEdit.setText(str(x[0]))

        self.statusBar().showMessage("Ready.")

    def writeModule(self):
        fname, ok = QFileDialog.getSaveFileName(self, 'Save Module', '.', 'Footprint (*.kicad_mod);;Any File (*)')
        if (not fname):
            return
        if (not fname.endswith('.kicad_mod')):
            fname = fname + '.kicad_mod'

        nTurns = float(self.nTurnsLineEdit.text())
        innerRadius = float(self.innerRadiusLineEdit.text())
        pitch = float(self.pitchLineEdit.text())
        spacing = float(self.spacingLineEdit.text())
        traceWidth = float(self.traceWidthLineEdit.text())
        nLayers = int(self.nLayersLineEdit.text())
        d = float(self.drawTolLineEdit.text())
        
        polygonVertexCount = None

        geometricPrimitives = None
        dir = 1
        inductorStyleIndex = self.indStyleCB.currentIndex()
        if (inductorStyleIndex == InductorStyle.CIRCULAR_SEGMENTS): # circular segments
            geometricPrimitives = dos.circ_spiral(nTurns, innerRadius, pitch, dir, d)
        elif (inductorStyleIndex == InductorStyle.CIRCULAR_ARCS): # circular arcs
            polygonVertexCount = int(self.polygonVertexCountLineEdit.text())
            geometricPrimitives = dos.arcs_spiral(nTurns, innerRadius, pitch, dir, polygonVertexCount)
        elif (inductorStyleIndex == InductorStyle.SQUARE): # rectangle
            geometricPrimitives = dos.square_spiral(nTurns, innerRadius, pitch)
          
        # Check if making an inductor from the given parameters is at all possible
        if (geometricPrimitives is None):
            self.showInvalidParametersErrorMsg()
        else:
            sm = dos.kmodule(fname)
            sm.write_header(name='SIND', descr='spiral inductor', tags='SMD')
            if (inductorStyleIndex == InductorStyle.CIRCULAR_SEGMENTS): # circular segments
                vx = geometricPrimitives
                sm.add_circ_spiral(vx, 'F.Cu', traceWidth)
                if (nLayers == 2):
                    pad1 = vx[-1] # inductor starts at end of top spiral
                    vx = dos.circ_spiral(nTurns, innerRadius, pitch, -dir, d)
                    sm.add_circ_spiral(vx, 'B.Cu', traceWidth)
                    sm.add_thru_pad('lc', 'circle', vx[0], dos.Point(0.6, 0.6), 0.3)
                    end_layer = 'B'
                else: # single-layer spiral
                    pad1 = vx[0] # inductor starts at center of spiral
                    end_layer = 'F'
                pad2 = vx[-1] # inductor ends always at end of last spiral
            elif (inductorStyleIndex == InductorStyle.CIRCULAR_ARCS): # circular arcs
                arcs = geometricPrimitives
                sm.add_arc_spiral(arcs, 'F.Cu', traceWidth)
                if (nLayers == 2):
                    # inductor starts at end of top spiral
                    p_end = arcs[-1][1].copy() # starting point of the last arc
                    p_center = arcs[-1][0] # centre of the last arc
                    theta = arcs[-1][2] # arc starting point
                    p_end.rotate_about(p_center, theta)  # end point of the circular arc
                    pad1 = p_end
                    arcs = dos.arcs_spiral(nTurns, innerRadius, pitch, -dir, polygonVertexCount)
                    sm.add_arc_spiral(arcs, 'B.Cu', traceWidth)
                    sm.add_thru_pad('lc', 'circle', arcs[0][1], dos.Point(0.6, 0.6), 0.3)
                    end_layer = 'B'
                else: # single-layer spiral
                    # inductor starts at center of spiral
                    pad1 = arcs[0][1] # starting point of the last arc
                    end_layer = 'F'
                # inductor ends always at end of last spiral
                p_end = arcs[-1][1].copy() # starting point of the last arc
                p_center = arcs[-1][0] # centre of the last arc
                theta = arcs[-1][2] # arc starting point
                p_end.rotate_about(p_center, theta)  # end point of the circular arc
                pad2 = p_end
            elif (inductorStyleIndex == InductorStyle.SQUARE): # rectangle
                vx = geometricPrimitives                
                sm.add_circ_spiral(vx, 'F.Cu', traceWidth)
                # single-layer spiral
                pad1 = vx[0] # inductor starts at center of spiral
                end_layer = 'F'
                
                pad2 = vx[-1] # inductor ends always at end of last spiral
            else:
                pass

            # add SMD pads at the beginning and end
            padSize = dos.Point(traceWidth/2.0, traceWidth/2.0)
            sm.add_smd_pad('1', 'rect', pad1, padSize, 'F')
            sm.add_smd_pad('2', 'rect', pad2, padSize, end_layer)

            #draw_arcs_spiral(nTurns, innerRadius, pitch, traceWidth, N, dir)
            sm.write_refs(0, 0, ref='REF**', value='LLL')
            sm.close()

    def estimateInductance(self):
        try:
            nTurns = float(self.nTurnsLineEdit.text())
            innerRadius = float(self.innerRadiusLineEdit.text())
            pitch = float(self.pitchLineEdit.text())
            traceWidth = float(self.traceWidthLineEdit.text())
            cuThickness = float(self.cuThicknessLineEdit.text())
            pcbThickness = float(self.pcbThicknessLineEdit.text())
            nLayers = int(self.nLayersLineEdit.text())
        except ValueError:
            return # do not estimate inductance for invalid values

        # compute inner and outer diameter for Mohan's formula
        din = 2 * innerRadius - traceWidth + pitch / 2.0
        dout = 2 * innerRadius + (2 * nTurns - 0.5) * pitch + traceWidth
        ind = dos.calc_ind(nTurns, dout / 1e3, din / 1e3)
        # print 'din =', din
        # print 'dout =', dout
        # print 'ind =', ind

        if (nLayers == 1):
            indtot = ind  # single-lyer inductor
        else:  # two-layer inductor
            k = dos.calc_mut(nTurns, pcbThickness * 1e-3)
            indtot = 2.0 * ind * (1.0 + k)

        self.estIndLineEdit.setText("%.3e" % (indtot * 1e6))


def main():
    app = QApplication(sys.argv)
    #app = QtGui.QApplication(sys.argv)
    form = kSpiralCalc()
    form.show()
    app.exec()

if __name__ == '__main__':
    main()