Ejemplo n.º 1
0
def create_test_circuit(fet_type, iparam, fet_L, fet_W, coner_path):
    c = Circuit('gm_id')
    c.include(
        '/home/tclarke/skywater-pdk/libraries/sky130_fd_pr/latest/models/corners/tt.spice'
    )
    fet_L = 0.15
    fet_W = 1

    # create the circuit
    c.V('gg', 1, c.gnd, 0 @ u_V)
    c.V('dd', 2, c.gnd, 1.8 @ u_V)
    c.X('M1',
        fet_type,
        2,
        1,
        c.gnd,
        c.gnd,
        L=fet_L,
        W=fet_W,
        ad="'W*0.29'",
        pd="'2*(W+0.29)'",
        as_="'W*0.29'",
        ps="'2*(W+0.29)'",
        nrd="'0.29/W'",
        nrs="'0.29/W'",
        sa=0,
        sb=0,
        sd=0,
        nf=1,
        mult=1)
    return c
Ejemplo n.º 2
0
def create_circuit(genome, config):
    libraries_path = '/home/alan/ngspice/libraries'  # os.path.join(os.path.dirname(os.path.dirname(__file__)), 'libraries')
    spice_library = SpiceLibrary(libraries_path)

    circuit = Circuit('NEAT')
    circuit.include(spice_library['1N4148'])

    Vbase = circuit.V('base', 'input1', circuit.gnd, 2)
    Vcc = circuit.V('cc', 'input2', circuit.gnd, 5)
    Vgnd = circuit.V('gnd', 'input3', circuit.gnd, 0)
    #circuit.R('test1', 'node0', circuit.gnd, 1e6)
    #circuit.R('test2', 'node0', 'input1', 1e6)
    ridx = 1
    xidx = 1
    for key, c in iteritems(genome.connections):
        if c.component == 'resistor':
            pin0, pin1 = get_pins(key)
            R = 10**c.value
            circuit.R(ridx, pin1, pin0, R)
            ridx += 1
        elif c.component == 'diode':
            pin0, pin1 = get_pins(key)
            circuit.X(xidx, '1N4148', pin1, pin0)
            xidx += 1

    return circuit
Ejemplo n.º 3
0
def nmos_characteristics(Vd, Vg):
    circuit = Circuit('NMOS Input Characteristic')
    circuit.include(
        './app/circuits/libraries/transistor/ptm_65nm_nmos_bulk.mod')

    # Define the DC supply voltage value
    Vdd = float(Vd)

    # Instanciate circuit elements
    Vgate = circuit.V('gate', 'gatenode', circuit.gnd, u_V(float(Vg)))
    Vdrain = circuit.V('drain', 'vdd', circuit.gnd, u_V(Vdd))
    # M <name> <drain node> <gate node> <source node> <bulk/substrate node>
    circuit.MOSFET(1,
                   'vdd',
                   'gatenode',
                   circuit.gnd,
                   circuit.gnd,
                   model='ptm65nm_nmos')

    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.dc(Vdrain=slice(0, Vdd, .01))

    figure, ax = plt.subplots(figsize=(20, 10))

    ax.plot(analysis['vdd'], u_A(-analysis.Vdrain))
    ax.legend('NMOS characteristic')
    ax.grid()
    ax.set_xlabel('Vds [V]')
    ax.set_ylabel('Id [A]')

    return circuit, analysis, plt
Ejemplo n.º 4
0
def simulate_attenuation_factor_core(w, R_1, R_2, C_1, C_2, optboolean=False):
    circuit = Circuit('Name me please')
    circuit.include(spice_library['D1N4148'])
    # TLV3201 is a 0-5 T.I. OpAmp
    circuit.include(spice_library['LM741'])
    V = 7
    #w = 20E3
    #circuit.V('1', circuit.gnd,1,f'DC 0 AC {V} SIN(0 {V} {w})')
    circuit.V('1', 1, circuit.gnd, f'DC 0 AC {V} SIN(0 {V} {w})')
    #R_1 = 11.2
    #R_2 = 11.2
    R_A = 100000
    R_B = 0.001
    #C_1 = 2000
    #C_2 = 1000
    links = [
        (1, 2),
        (2, 3),
        (circuit.gnd, 4),
        (4, 5),
    ]
    R_vector = [
        R_1,
        R_2,
        R_A,
        R_B,
    ]
    for x in range(len(R_vector)):
        circuit.R(str(x + 1), links[x][0], links[x][1], R_vector[x] @ u_kΩ)
    circuit.C('1', 2, 5, C_1 @ u_pF)
    circuit.C('2', circuit.gnd, 3, C_2 @ u_pF)
    circuit.X('opamp', 'LM741', 3, 4, 'Vcc', 'Vee', 5)
    circuit.V('2', 'Vcc', circuit.gnd, 'DC +15')
    circuit.V('3', 'Vee', circuit.gnd, 'DC -15')
    if optboolean:
        circuit.X('diodus', 'D1N4148', 2, 1)
    f = w
    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.transient(step_time=((1 / f) / 10) @ u_s,
                                   end_time=(4 / f) @ u_s)  # Printer?
    if False:
        #print(str(circuit))
        fig = plt.figure(figsize=(20, 4))  # create a figure object
        ax = fig.add_subplot(1, 1, 1)
        plt.plot(analysis['1'] - analysis['2'], label='R')
        plt.plot(analysis['2'] - analysis['3'], label='L')
        ax.plot(analysis['3'], label='C')
        #ax.set_ylim(-int(V*1.1)-10,int(V*1.1)+10)
        ax.legend()
        ax.set_title(f'freq : {w}')
        print(f'resonance was at {np.sqrt(1/(L*C))}')
    if True:
        outputter = max(analysis['5'])
        del (circuit)
        return outputter
    return
Ejemplo n.º 5
0
def simple_bjt_amp():
    circuit = Circuit('test circuit')
    model_npn = set_model_qbc847b(circuit)
    n = NodeNames('n1', 'n2', 'n3', 'n4', 'n5')
    gnd = 0
    circuit.R('1', n.n3, n.n2, 2.2e6)
    circuit.Q('1', n.n3, n.n2, gnd, model=model_npn)
    circuit.R('3', n.n1, n.n3, 1e3)
    circuit.C('1', n.n4, n.n2, 100e-9)
    circuit.C('2', n.n3, n.n5, 1e-6)
    circuit.C('4', n.n1, n.n3, 10e-9)
    circuit.R('5', n.n5, gnd, 10e3)
    circuit.V('pwr', n.n1, gnd, 6)
    circuit.V('in', n.n4, gnd, 'dc 0 ac 1 distof1 1 distof2 0.1')
    return circuit, n
Ejemplo n.º 6
0
    def test_ground_node(self):

        circuit = Circuit('')
        circuit.V('input', 'in', circuit.gnd, '10V')
        circuit.R(1, 'in', 'out', 9 @ u_kΩ)
        circuit.R(2, 'out', circuit.gnd, 1 @ u_kΩ)

        self.assertTrue(circuit.has_ground_node())

        circuit = Circuit('')
        circuit.V('input', 'in', 'fake_ground', '10V')
        circuit.R(1, 'in', 'out', 9 @ u_kΩ)
        circuit.R(2, 'out', 'fake_ground', 1 @ u_kΩ)

        self.assertFalse(circuit.has_ground_node())
Ejemplo n.º 7
0
def createCircuit(filter1o, filter2o):
    circuit = Circuit('Filter')
    circuit.include('Models/BasicOpamp.cir')
    circuit.include('Models/AD8619.cir')
    circuit.include('Models/TL084.cir')
    circuit.subcircuit(filter1o)
    circuit.subcircuit(filter2o)

    circuit.V('1', '5V', circuit.gnd, '5')
    circuit.V('2', 'VRef', circuit.gnd, '2.5')
    circuit.SinusoidalVoltageSource('In', 'In', 'VRef', amplitude=1)
    circuit.X('1', filter1o.name, 'In', 'out1o', 'VRef', '5V', circuit.gnd)
    circuit.X('2', filter2o.name, 'In', 'out2o', 'VRef', '5V', circuit.gnd)

    print(circuit)
    return circuit
Ejemplo n.º 8
0
def simulate_RLC(w=2000,V=2,R=10,L=3,C=320,**kwargs):

    circuit = Circuit('Name me please')
    circuit.R('1',  1, 2,R@u_kΩ)
    circuit.L('1',  2, 3,L@u_H)
    circuit.C('1',  3, 0,C@u_nF)
    #circuit.V('1',  circuit.gnd,1 ,f'SIN(0 {V} {w})')
    circuit.V('1',0,1, f'DC 0 AC {V} SIN(0 {V} {w})')
    dt = 2*np.pi/w*4
    tf = 5/w
    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    #analysis = simulator.transient(step_time=0.1@u_ms, end_time=tf@u_s)
    analysis = simulator.transient(step_time=dt@u_ms, end_time=tf@u_s)

    if kwargs.get('view',False):
        #print(str(circuit))
        fig = plt.figure(figsize=(20,4))  # create a figure object
        ax = fig.add_subplot(1, 1, 1)
        plt.plot(analysis['1']-analysis['2'],label='R')
        plt.plot(analysis['2']-analysis['3'],label='L')
        ax.plot(analysis['3'],label='C')
        #ax.set_ylim(-int(V*1.1)-10,int(V*1.1)+10)
        ax.legend()
        ax.set_title(f'freq : {w}, voltage: {V}')
        ax.set_xlabel('time (ms)')
        ax.set_ylabel('current (ma)')
        plt.savefig('gallery/RLC_example.png')
        print(f'resonance was at {np.sqrt(1/(L*C))}')
    return max(abs(analysis['1']-analysis['2']))/R
Ejemplo n.º 9
0
    def test_spinit(self):

        from PySpice.Spice.Netlist import Circuit
        import PySpice.Unit as U

        circuit = Circuit('Astable Multivibrator')

        source = circuit.V('cc', 'vcc', circuit.gnd, 15 @ U.u_V)
        circuit.R(1, 'output', 'comparator', 1 @ U.u_kΩ)
        circuit.C(1, 'comparator', circuit.gnd, 100 @ U.u_nF)
        circuit.R(2, 'output', 'reference', 100 @ U.u_kΩ)
        circuit.R(3, 'vcc', 'reference', 100 @ U.u_kΩ)
        circuit.R(4, 'reference', circuit.gnd, 100 @ U.u_kΩ)
        circuit.NonLinearVoltageSource(1,
                                       'output',
                                       circuit.gnd,
                                       expression='V(reference, comparator)',
                                       table=((-U.micro(1), 0),
                                              (U.micro(1), source.dc_value)))

        simulator = circuit.simulator(temperature=25, nominal_temperature=25)
        simulator.initial_condition(
            comparator=0)  # Fixme: simulator.nodes.comparator == 0
        analysis = simulator.transient(step_time=1 @ U.u_us,
                                       end_time=500 @ U.u_us)

        if (len(analysis.output)) < 500:
            raise NameError('Simualtion failed')
    def test_spinit(self):

        from PySpice.Spice.Netlist import Circuit
        import PySpice.Unit as U

        circuit = Circuit('Test')

        # Fixme: On Windows
        #   Supplies reduced to   2.5749% Supplies reduced to   1.7100% Warning: source stepping failed
        #   doAnalyses: Too many iterations without convergence
        source = circuit.V('cc', 'vcc', circuit.gnd, 15 @ U.u_V)
        circuit.R(1, 'output', 'comparator', 1 @ U.u_kΩ)
        circuit.C(1, 'comparator', circuit.gnd, 100 @ U.u_nF)
        circuit.R(2, 'output', 'reference', 100 @ U.u_kΩ)
        circuit.R(3, 'vcc', 'reference', 100 @ U.u_kΩ)
        circuit.R(4, 'reference', circuit.gnd, 100 @ U.u_kΩ)
        # circuit.NonLinearVoltageSource(1, 'output', circuit.gnd,
        #                                expression='V(reference, comparator)',
        #                                table=((-U.micro(1), 0),
        #                                       (U.micro(1), source.dc_value))
        # )

        simulator = circuit.simulator(temperature=25, nominal_temperature=25)
        simulator.initial_condition(
            comparator=0)  # Fixme: simulator.nodes.comparator == 0
        analysis = simulator.transient(step_time=1 @ U.u_us,
                                       end_time=500 @ U.u_us)

        if (len(analysis.output)) < 500:
            raise NameError('Simualtion failed')
Ejemplo n.º 11
0
def make_database_core(w, V, R_1, R_2, C_1, C_2, ax=False):
    circuit = Circuit('Sallen-key low-pass-filter')
    circuit.include(spice_library['D1N4148'])
    circuit.include(spice_library['LM741'])
    circuit.V('1', 1, circuit.gnd, f'DC 0 AC {V} SIN(0 {V} {w})')
    R_A = 100000
    R_B = 0.001
    links = [
        (1, 2),
        (2, 3),
        (circuit.gnd, 4),
        (4, 5),
    ]
    R_vector = [
        R_1,
        R_2,
        R_A,
        R_B,
    ]
    for x in range(len(R_vector)):
        circuit.R(str(x + 1), links[x][0], links[x][1], R_vector[x] @ u_kΩ)
    circuit.C('1', 2, 5, C_1 @ u_pF)
    circuit.C('2', circuit.gnd, 3, C_2 @ u_pF)
    circuit.X('opamp', 'LM741', 3, 4, 'Vcc', 'Vee', 5)
    circuit.V('2', 'Vcc', circuit.gnd, 'DC +15')
    circuit.V('3', 'Vee', circuit.gnd, 'DC -15')
    circuit.X('diodus', 'D1N4148', 2, 1)
    f = w
    tf = 3 / w
    t0 = 1
    treshold = 4
    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.transient(step_time=((1 / f) / 10) @ u_s,
                                   end_time=3 / w @ u_s)
    if False:
        ax.plot(analysis['5'], label='output')
        ax.plot(analysis['1'], label='input')
        ax.plot(analysis['1'] - analysis['2'], label='diodo')
        ax.hlines(4, 0, 5 / w)
        ax.legend()
        ax.set_title(
            f'R1: {R_1}, R2: {R_2}, C1: {C_1}, C2: {C_2}, V: {V}, W: {w}')
        ax.set_ylim(-15, 15)
    auxiliar = analysis['2'] - analysis['1']
    del (circuit)
    return [w, V, R_1, R_2, C_1, C_2, int(float(max(auxiliar)) > treshold)]
Ejemplo n.º 12
0
def simulate_amplification_factor_core(R1,R2,RC,RE,RL,C1,C2,V,w):
    circuit = Circuit('Amplifier')
    circuit.R(1, 5, 2, R1@u_kΩ) #kOhm 
    circuit.R(2, 2, 0, R2@u_kΩ)  #kOhm
    circuit.R('C', 5, 4, RC@u_kΩ) #kOhm
    circuit.R('E', 3, 0, RE@u_kΩ)  #kOhm
    circuit.R('Load', 'out', 0, RL@u_MΩ)  #MOhm
    circuit.C(1, 'inp', 2, C1@u_uF)    #uF
    circuit.C(2, 4, 'out', C2@u_uF)   #uF
    circuit.BJT(1, 4, 2, 3, model='bjt') # Q is mapped to BJT !
    circuit.model('bjt', 'npn', bf=80, cjc=pico(5), rb=100)
    circuit.V('power', 5, circuit.gnd, 15@u_V)
    circuit.V('var','inp',circuit.gnd, f'DC 0 AC {V} SIN(0 {V}V {w})')
    T = 25
    simulator = circuit.simulator(temperature=T, nominal_temperature=T)
    analysis = simulator.transient(step_time = (2*np.pi/w/20)@u_s,end_time=(2*np.pi/w*4)@u_s)
    return [float(min(analysis['out']))]
Ejemplo n.º 13
0
def simulate_amplifier():
    circuit = Circuit('Amplifier')
    R_1 = [100]
    R_2 = [20]
    R_C = [10]
    R_E = [2]
    R_L = [1]
    C_1 = [10]
    C_2 = [10]
    R1 = random.choice(R_1)
    R2 = random.choice(R_2)
    RC = random.choice(R_C)
    RE = random.choice(R_E)
    RL = random.choice(R_L)
    C1 = random.choice(C_1)
    C2 = random.choice(C_2)
    circuit.R(1, 5, 2, R1@u_kΩ) #kOhm 
    circuit.R(2, 2, 0, R2@u_kΩ)  #kOhm
    circuit.R('C', 5, 4, RC@u_kΩ) #kOhm
    circuit.R('E', 3, 0, RE@u_kΩ)  #kOhm
    circuit.R('Load', 'out', 0, RL@u_MΩ)  #MOhm
    circuit.C(1, 'in', 2, C1@u_uF)    #uF
    circuit.C(2, 4, 'out', C2@u_uF)   #uF
    circuit.BJT(1, 4, 2, 3, model='bjt') # Q is mapped to BJT !
    circuit.model('bjt', 'npn', bf=80, cjc=pico(5), rb=100)
    V_vector = [0.5]
    w_vector = [1E3]
    V = random.choice(V_vector)
    w = random.choice(w_vector)
    circuit.V('power', 5, circuit.gnd, 15@u_V)
    circuit.V('var','in',circuit.gnd, f'DC 0 AC {V} SIN(0 {V}V {w})')
    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.transient(step_time = (1/w/25)@u_s,end_time=(4/w)@u_s)
    figure = plt.figure(1, (20, 10))
    axe = plt.subplot(111)
    plt.title('')
    plt.xlabel('Time [s]')
    plt.ylabel('Voltage [V]')
    plt.grid()
    plot(analysis['in'], axis=axe)
    plot(analysis.out, axis=axe)
    plt.legend(('input', 'output'), loc=(.05,.1))
    plt.tight_layout()
    plt.savefig('gallery/amplifier.png')
    return
Ejemplo n.º 14
0
def simulate_sallen_key_low_pass_filter():
    # Initialize the Circuit
    circuit = Circuit('Sallen-key low-pass-filter')
    # Include the active element: operational amplifier
    circuit.include(spice_library['LM741'])
    V = 2
    w = 2E3
    circuit.V('1', 1, circuit.gnd, f'DC 0 AC {V} SIN(0 {V} {w})')
    R_1 = 11.2
    R_2 = 11.2
    R_A = 1000
    R_B = 0.01
    C_1 = 200
    C_2 = 100
    links = [
        (1, 2),
        (2, 3),
        (circuit.gnd, 4),
        (4, 5),
    ]
    R_vector = [
        R_1,
        R_2,
        R_A,
        R_B,
    ]
    for x in range(len(R_vector)):
        circuit.R(str(x + 1), links[x][0], links[x][1], R_vector[x] @ u_kΩ)
    circuit.C('1', 2, 5, C_1 @ u_pF)
    circuit.C('2', circuit.gnd, 3, C_2 @ u_pF)
    circuit.X('opamp', 'LM741', 3, 4, 'Vcc', 'Vee', 5)
    circuit.V('2', 'Vcc', circuit.gnd, 'DC +15')
    circuit.V('3', 'Vee', circuit.gnd, 'DC -15')
    f = w
    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.transient(step_time=((1 / f) / 10) @ u_s,
                                   end_time=(4 / f) @ u_s)
    fig, ax = plt.subplots(figsize=(20, 5))
    ax.plot(analysis['5'], label='out')
    ax.plot(analysis['1'], label='in')
    ax.legend()
    plt.savefig('gallery/sallen-key-low-pass-filter_example.png')
Ejemplo n.º 15
0
def voltage_divider(v, r1, r2):
    circuit = Circuit('Voltage Divider')
    circuit.V('input', 1, circuit.gnd, u_V(float(v)))
    circuit.R(1, 1, 2, u_kOhm(float(r1)))
    circuit.R(2, 2, circuit.gnd, u_kOhm(float(r2)))
    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.operating_point()
    output = {}
    for node in analysis.nodes.values():
        output[str(node)] = str(round(float(node), 2)) + "V"

    return circuit, analysis, output
Ejemplo n.º 16
0
def make_database_core(R1,R2,RC,RE,RL,C1,C2,V,w,l=False):
    circuit = Circuit('Amplifier')
    circuit.R(1, 5, 2, R1@u_kΩ) #kOhm 
    circuit.R(2, 2, 0, R2@u_kΩ)  #kOhm
    circuit.R('C', 5, 4, RC@u_kΩ) #kOhm
    circuit.R('E', 3, 0, RE@u_kΩ)  #kOhm
    circuit.R('Load', 'out', 0, RL@u_MΩ)  #MOhm
    circuit.C(1, 'inp', 2, C1@u_uF)    #uF
    circuit.C(2, 4, 'out', C2@u_uF)   #uF
    circuit.BJT(1, 4, 2, 3, model='bjt') # Q mapped to BJT 
    circuit.model('bjt', 'npn', bf=80, cjc=pico(5), rb=100)
    circuit.V('power', 5, circuit.gnd, 15@u_V)
    circuit.V('var','inp',circuit.gnd, f'DC 0 AC {V} SIN(0 {V}V {w})')
    circuit.include(spice_library['D1N4148']) 
    circuit.X('diode','D1N4148',3,2)
    T = 25
    simulator = circuit.simulator(temperature=T, nominal_temperature=T)
    analysis = simulator.transient(step_time = (1/w/10)@u_s,end_time=(2/w)@u_s)
    treshold = 4
    return [R1,R2,RC,RE,RL,C1,C2,V,w,
            int(treshold<float(max(analysis['3']-analysis['2'])))]
Ejemplo n.º 17
0
    def setup_circuit(kind="biased"):
        if kind=="biased":
            circuit = Circuit('Biased Envelope Circuit')
            circuit.include(spice_library['hsms'])

            circuit.V('in', 'input', circuit.gnd, 'dc 0 external')
            # bias portion
            circuit.C(2, 'input', 1, 10@u_nF)
            circuit.R(2, 1, 2, 1@u_kOhm)
            circuit.X('D2', 'hsms', 2, circuit.gnd)
            circuit.R(3, 2, 'bias', 1@u_kOhm)
            circuit.V('bias', 'bias', circuit.gnd, 5@u_V)
            # envelope portion
            circuit.X('D1', 'hsms', 1, 'output')
            circuit.C(1, 'output', circuit.gnd, 220@u_pF)
            circuit.R(1, 'output', circuit.gnd, 50@u_Ohm)
            return circuit

        elif kind=="basic":
            circuit = Circuit('Biased Envelope Circuit')
            circuit.include(spice_library['hsms'])

            circuit.V('in', 'input', circuit.gnd, 'dc 0 external')
            # envelope portion
            circuit.X('D1', 'hsms', 'input', 'output')
            circuit.C(1, 'output', circuit.gnd, 220@u_pF)
            circuit.R(1, 'output', circuit.gnd, 50@u_Ohm)
            return circuit

        elif kind=="diode":
            circuit = Circuit('Diode Output')
            circuit.include(spice_library['hsms'])
            
            circuit.V('in', 'input', circuit.gnd, 'dc 0 external')
            circuit.X('D1', 'hsms', 'input', 'output')
            return circuit
Ejemplo n.º 18
0
def simulate_attenuation_factor_core(w, V, R, C):
    circuit = Circuit('RC low-pass filter')
    fc = 1 / 2 / 3.14 / (R * 1000) / (C * 1E-9)
    circuit.V('1', 1, circuit.gnd, f'DC 0 AC {V} SIN(0 {V} {w})')
    circuit.R('1', 1, 2, R @ u_kΩ)
    circuit.C('1', 2, circuit.gnd, C @ u_nF)
    f = w / 2 / np.pi
    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.transient(step_time=((1 / f) / 10) @ u_s,
                                   end_time=(4 / f) @ u_s)
    if True:
        outputter = max(analysis['2'])
        del (circuit)
        return outputter
    return
Ejemplo n.º 19
0
def make_database_core(w=2000,V=12,R=10,L=3,C=320):
    threshold = 4
    circuit = Circuit('RLC-series')
    circuit.V('1',0,1, f'DC 0 AC {V} SIN(0 {V} {w})')
    circuit.R('1',  1, 2,R@u_kΩ)
    circuit.L('1',  2, 3,L@u_H)
    circuit.X('diodus','D1N4148', 2, 3)
    circuit.include(spice_library['D1N4148']) 
    circuit.C('1',  3, 0,C@u_nF)
    dt = 2*np.pi/w*4
    tau = 2*np.pi/w*4
    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.transient(step_time=dt@u_ms, end_time=tau@u_s)
    auxiliar = analysis['2']-analysis['3']
    return [w,V,R,L,C,int(float(max(auxiliar))>threshold)]
Ejemplo n.º 20
0
    def test_raw_spice(self):

        spice_declaration = """
.title Voltage Divider

R2 out 0 1kOhm
vinput in 0 10v
r1 in out 9kohm
"""
        # .end

        circuit = Circuit('Voltage Divider')
        circuit.V('input', 'in', circuit.gnd, '10V')
        circuit.R(1, 'in', 'out', raw_spice='9kOhm')
        circuit.raw_spice += 'R2 out 0 1kOhm'
        self._test_spice_declaration(circuit, spice_declaration)
Ejemplo n.º 21
0
    def skip_test_resistance(
            self):  # this test works, it just doesn't run on Travis yet.
        Rexe = 0.0000001
        Rexc = 0.0000001
        Rwe = 0.2545383947014702
        Rwke = 0.7943030881649811
        Rv = 8.852701208752846e-06
        Rintere = 0.00034794562965549745
        Rinterc = 0.00017397281482774872
        Rwkc = 0.39715154408249054
        Rwka = 744.3007160198263
        Rwa = 456.90414284754644
        Rwc = 0.1272691973507351

        circuit = PyCircuit('HeatPipe')

        circuit.V('input', 1, circuit.gnd, 80 @ u_V)
        circuit.R('Reex', 1, 2, 0.0000001 @ u_kΩ)
        circuit.R('Rew', 2, 3, 0.2545383947014702 @ u_kΩ)
        circuit.R('Rewk', 3, 4, 0.7943030881649811 @ u_kΩ)
        circuit.R('Rintere', 4, 5, 0.00034794562965549745 @ u_kΩ)
        circuit.R('Raw', 2, 9, 456.90414284754644 @ u_kΩ)
        circuit.R('Rawk', 3, 8, 744.3007160198263 @ u_kΩ)
        circuit.R('Rv', 5, 6, 8.852701208752846e-06 @ u_kΩ)
        circuit.R('Rinterc', 6, 7, 0.00017397281482774872 @ u_kΩ)
        circuit.R('Rcwk', 7, 8, 0.39715154408249054 @ u_kΩ)
        circuit.R('Rcw', 8, 9, 0.1272691973507351 @ u_kΩ)
        circuit.R('Rcex', 9, circuit.gnd, 0.0000001 @ u_kΩ)

        for resistance in (circuit.RReex, circuit.RRcex):
            resistance.minus.add_current_probe(
                circuit)  # to get positive value

        simulator = circuit.simulator(temperature=25, nominal_temperature=25)
        analysis = simulator.operating_point()

        for node in analysis.nodes.values():
            print('Node {}: {:5.2f} V'.format(
                str(node), float(node)))  # Fixme: format value + unit

        #Pyspice treates ground as 0, need to offset by base temperature (circ.Rex_c.T_out = 20degC)

        assert_near_equal(self.prob.get_val('circ.n3.T'),
                          float(analysis.nodes['4']) + 20.,
                          tolerance=1.0E-5)
Ejemplo n.º 22
0
def make_database_core(w, V, R, C):
    circuit = Circuit('RC low-pass filter')
    # Include non-passive elements:
    # D1N4148 is a (regular&cheap) Diode
    circuit.include(spice_library['D1N4148'])
    fc = 1 / 2 / 3.14 / (R * 1000) / (C * 1E-9)  # Cut Frequency!
    circuit.V('1', 1, circuit.gnd, f'DC 0 AC {V} SIN(0 {V} {w})')
    circuit.R('1', 1, 2, R @ u_kΩ)
    circuit.C('1', 2, circuit.gnd, C @ u_nF)
    circuit.X('diodus', 'D1N4148', 2, circuit.gnd)
    f = w
    treshold = 4
    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.transient(step_time=((1 / f) / 10) @ u_s,
                                   end_time=(4 / f) @ u_s)
    outputter = int(float(max(-analysis['2'])) > treshold)
    del (circuit)
    return [w, V, R, C, outputter]
Ejemplo n.º 23
0
    def test_basic(self):

        spice_declaration = """
.title Voltage Divider

vinput in 0 10v
r1 in out 9kohm
r2 out 0 1kohm
"""
        # .end

        circuit = Circuit('Voltage Divider')
        circuit.V('input', 'in', circuit.gnd, '10V')
        circuit.R(1, 'in', 'out', 9 @ u_kΩ)
        circuit.R(2, circuit['out'], circuit.gnd,
                  1 @ u_kΩ)  # out node is defined
        self._test_spice_declaration(circuit, spice_declaration)

        circuit = VoltageDividerCircuit()
        self._test_spice_declaration(circuit, spice_declaration)

        self._test_nodes(circuit, (0, 'in', 'out'))

        self.assertTrue(circuit['R1'].minus.node is circuit['out'])

        self.assertEqual(str(circuit['R1'].plus.node), 'in')
        self.assertEqual(str(circuit['R1'].minus.node), 'out')

        self.assertEqual(str(circuit['in']), 'in')
        self.assertEqual(str(circuit['out']), 'out')
        #self.assertEqual(str(circuit.out), 'out')

        # for pin in circuit.out:
        #     print(pin)

        self.assertEqual(circuit['out'].pins,
                         set((circuit['R1'].minus, circuit['R2'].plus)))

        self.assertEqual(circuit['R1'].resistance, 9 @ u_kΩ)
        self.assertEqual(circuit['R2'].resistance, 1 @ u_kΩ)

        circuit['R1'].resistance = 10 @ u_kΩ
        self._test_spice_declaration(circuit,
                                     spice_declaration.replace('9k', '10k'))
Ejemplo n.º 24
0
def simulate_RC_filter():
    # Initialize the Circuit
    circuit = Circuit('RC low-pass filter')
    # Set the element's values
    V = 2
    w = 1E3
    R = 1
    C = 30
    fc = 1 / 2 / 3.14 / (R * 1000) / (C * 1E-9)
    circuit.V('1', 1, circuit.gnd, f'DC 0 AC {V} SIN(0 {V} {w})')
    circuit.R('1', 1, 2, R @ u_kΩ)
    circuit.C('1', 2, circuit.gnd, C @ u_nF)
    # Simulate
    f = w / 2 / np.pi
    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.transient(step_time=((1 / f) / 10) @ u_s,
                                   end_time=(4 / f) @ u_s)
    fig, ax = plt.subplots(figsize=(20, 5))
    ax.plot(analysis['2'], label='out')
    ax.plot(analysis['1'], label='in')
    ax.legend()
    plt.savefig('gallery/RC-low-pass-filter_example.png')
Ejemplo n.º 25
0
    def thread_function(qin, qout, clk_freq, init_x):
        try:

            c = Circuit('pygears')
            ins = []
            outs = []
            f(c, ins, outs)

            c.V('__x', ins[0][0], ins[0][1], f'dc {init_x} external')

            ngspice_shared = PgNgSpice(qin,
                                       qout,
                                       x=init_x,
                                       outs=outs,
                                       send_data=True)

            simulator = c.simulator(temperature=25,
                                    nominal_temperature=25,
                                    simulator='ngspice-shared',
                                    ngspice_shared=ngspice_shared)

            simulator.transient(step_time=1 / (2 * clk_freq), end_time=1e3)
        except GearDone:
            pass
libraries_path = os.path.join(os.environ['PySpice_examples_path'], 'libraries')
spice_library = SpiceLibrary(libraries_path)

####################################################################################################

#!# For this purpose, we use the common high-speed diode 1N4148.  The diode is driven by a variable
#!# voltage source through a limiting current resistance.

#cm# diode-characteristic-curve-circuit.m4

circuit = Circuit('Diode Characteristic Curve')

circuit.include(spice_library['1N4148'])

circuit.V('input', 'in', circuit.gnd, 10 @ u_V)
circuit.R(1, 'in', 'out', 1 @ u_Ω)  # not required for simulation
circuit.X('D1', '1N4148', 'out', circuit.gnd)

#!# We simulate the circuit at these temperatures: 0, 25 and 100 °C.

temperatures = [0, 25, 100] @ u_Degree
analyses = {}
for temperature in temperatures:
    simulator = circuit.simulator(temperature=temperature,
                                  nominal_temperature=temperature)
    analysis = simulator.dc(Vinput=slice(-2, 5, .01))
    analyses[float(temperature)] = analysis

####################################################################################################
Ejemplo n.º 27
0
libraries_path = find_libraries()
spice_library = SpiceLibrary(libraries_path)

####################################################################################################

figure = plt.figure(1, (20, 10))

####################################################################################################

#r# We define a basic circuit to drive an NPN transistor (2n2222a) using two voltage sources.

#f# circuit_macros('transistor.m4')

circuit = Circuit('Transistor')

Vbase = circuit.V('base', '1', circuit.gnd, 1@u_V)
circuit.R('base', 1, 'base', 1@u_kΩ)
Vcollector = circuit.V('collector', '2', circuit.gnd, 0@u_V)
circuit.R('collector', 2, 'collector', 1@u_kΩ)
# circuit.BJT(1, 'collector', 'base', circuit.gnd, model='generic')
# circuit.model('generic', 'npn')
circuit.include(spice_library['2n2222a'])
circuit.BJT(1, 'collector', 'base', circuit.gnd, model='2n2222a')

#r# We plot the base-emitter diode curve :math:`Ib = f(Vbe)` using a DC sweep simulation.

simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.dc(Vbase=slice(0, 3, .01))

axe1 = plt.subplot(221)
axe1.plot(analysis.base, u_mA(-analysis.Vbase)) # Fixme: I_Vbase
Ejemplo n.º 28
0
import PySpice.Logging.Logging as Logging
logger = Logging.setup_logging()

####################################################################################################

from PySpice.Probe.Plot import plot
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *

# from OperationalAmplifier import basic_comparator

####################################################################################################

circuit = Circuit('Astable Multivibrator')

source = circuit.V('cc', 'vcc', circuit.gnd, 15 @ u_V)
# Time constant
circuit.R(1, 'output', 'comparator', 1 @ u_kΩ)
circuit.C(1, 'comparator', circuit.gnd, 100 @ u_nF)
# Reference
circuit.R(2, 'output', 'reference', 100 @ u_kΩ)
circuit.R(3, 'vcc', 'reference', 100 @ u_kΩ)
circuit.R(4, 'reference', circuit.gnd, 100 @ u_kΩ)
# Comparator
# Fixme: ngspice is buggy with such subcircuit
# circuit.subcircuit(basic_comparator)
# circuit.X('comparator', 'BasicComparator', 'reference', 'comparator', 'vcc', circuit.gnd, 'output')
circuit.NonLinearVoltageSource(1,
                               'output',
                               circuit.gnd,
                               expression='V(reference, comparator)',
Ejemplo n.º 29
0
        return 0

    ##############################################

    def get_isrc_data(self, current, time, node, ngspice_id):
        self._logger.debug('ngspice_id-{} get_isrc_data @{} node {}'.format(
            ngspice_id, time, node))
        current[0] = 1.
        return 0


####################################################################################################

circuit = Circuit('Voltage Divider')

circuit.V('input', 'input', circuit.gnd, 'dc 0 external')
circuit.R(1, 'input', 'output', 10 @ u_kΩ)
circuit.R(2, 'output', circuit.gnd, 1 @ u_kΩ)

amplitude = 10 @ u_V
frequency = 50 @ u_Hz
ngspice_shared = MyNgSpiceShared(amplitude=amplitude,
                                 frequency=frequency,
                                 send_data=False)
simulator = circuit.simulator(temperature=25,
                              nominal_temperature=25,
                              simulator='shared',
                              ngspice_shared=ngspice_shared)
period = float(frequency.period)
analysis = simulator.transient(step_time=period / 200, end_time=period * 2)
####################################################################################################

import PySpice.Logging.Logging as Logging
logger = Logging.setup_logging()

####################################################################################################

from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *

####################################################################################################

thevenin_circuit = Circuit('Thévenin Representation')

thevenin_circuit.V('input', 1, thevenin_circuit.gnd, 10 @ u_V)
thevenin_circuit.R('generator', 1, 'load', 10 @ u_Ω)
thevenin_circuit.R('load', 'load', thevenin_circuit.gnd, 1 @ u_kΩ)

simulator = thevenin_circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.operating_point()

load_node = analysis.load
print('Node {}: {:5.2f} V'.format(str(load_node), float(load_node)))
#o#

norton_circuit = Circuit('Norton Representation')

norton_circuit.I(
    'input', norton_circuit.gnd, 'load',
    thevenin_circuit.Vinput.dc_value / thevenin_circuit.Rgenerator.resistance)