Example #1
0
def freq_resp():
    shutil.copyfile('PA13.LIB', '/tmp/PA13.LIB')
    shutil.copyfile('op27.cir', '/tmp/op27.cir')
    circuit = Circuit('Freq Response')
    circuit.include('/tmp/PA13.LIB')
    circuit.include('/tmp/op27.cir')
    circuit.subcircuit(PA13Amplifier(Z_1, Z_2))
    circuit.subcircuit(OP27Amplifier(R_4, C_4))

    # V_Ir input
    circuit.SinusoidalVoltageSource('input', 'vr', circuit.gnd, amplitude=0.05)
    circuit.R('r3', 'vir', 'vir2', Z_3)
    # Current controller stage
    circuit.X('curr', 'op27_amplifier', 'vir2', 'vr')
    # Voltage stage
    circuit.X('volt', 'pa13_amplifier', 'vr', 'vo')
    # Motor stage
    circuit.R('rm', 'vo', 'vm1', R_m)
    circuit.L('lm', 'vm1', 'vio', L_m)

    circuit.R('rs', 'vio', circuit.gnd, R_s)
    circuit.R('r5', 'vio', 'vir2', Z_5)

    simulator = circuit.simulator()
    # Force ngspice to have shorter time steps near sharp transitions
    simulator.options(trtol=0.0001)
    import pdb
    pdb.set_trace()
    analysis = simulator.ac(
        start_frequency=50e0,
        stop_frequency=5 * f_h,
        number_of_points=1000,  # Lab manual suggests 20, might as well do more
        variation='dec')
    return analysis
Example #2
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
Example #3
0
def negative_clamper(v, r, c, f):
    print(v, r, c, f)
    circuit = Circuit('Negative Clamper')
    circuit.include('./app/circuits/libraries/diode/switching/1N4148.lib')
    source = circuit.SinusoidalVoltageSource('input',
                                             'in',
                                             circuit.gnd,
                                             amplitude=u_V(float(v)),
                                             frequency=u_Hz(float(f)))
    circuit.C('C1', 'in', 'output', u_mF(float(c)))
    circuit.X('D1', '1N4148', 'output', circuit.gnd)
    circuit.R('load', 'output', circuit.gnd, u_Ohm(float(r)))

    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.transient(step_time=source.period / 200,
                                   end_time=source.period * 2)
    plt.close('all')
    plt.title('Negative Clamper')
    plt.xlabel('Time [s]')
    plt.ylabel('Voltage [V]')
    plt.grid()
    plt.plot(analysis['in'])
    plt.plot(analysis.output)
    plt.legend(('input', 'output'), loc=(.05, .1))

    plt.tight_layout()

    return circuit, analysis, plt
Example #4
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
Example #5
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
Example #6
0
def full_wave_rectifier(v, r, c, f):
    circuit = Circuit('Full-wave rectification')
    circuit.include('./app/circuits/libraries/diode/switching/1N4148.lib')
    source = circuit.SinusoidalVoltageSource('input',
                                             'in',
                                             circuit.gnd,
                                             amplitude=u_V(float(v)),
                                             frequency=u_Hz(float(f)))
    circuit.X('D1', '1N4148', 'in', 'output_plus')
    circuit.R('load', 'output_plus', 'output_minus', u_Ω(float(r)))
    circuit.X('D2', '1N4148', 'output_minus', circuit.gnd)
    circuit.X('D3', '1N4148', circuit.gnd, 'output_plus')
    circuit.X('D4', '1N4148', 'output_minus', 'in')

    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.transient(step_time=source.period / 200,
                                   end_time=source.period * 2)
    plt.close('all')
    figure, (ax3, ax4) = plt.subplots(2, figsize=(20, 10))

    ax3.set_title('Full-Wave Rectification')
    ax3.set_xlabel('Time [s]')
    ax3.set_ylabel('Voltage [V]')
    ax3.grid()
    ax3.plot(analysis['in'])
    ax3.plot(analysis.output_plus - analysis.output_minus)
    ax3.legend(('input', 'output'), loc=(.05, .1))
    ax3.set_ylim(float(-source.amplitude * 1.1), float(source.amplitude * 1.1))

    circuit.C('1', 'output_plus', 'output_minus', u_mF(float(c)))

    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.transient(step_time=source.period / 200,
                                   end_time=source.period * 2)

    ax4.set_title('Full-Wave Rectification with filtering')
    ax4.set_xlabel('Time [s]')
    ax4.set_ylabel('Voltage [V]')
    ax4.grid()
    ax4.plot(analysis['in'])
    ax4.plot(analysis.output_plus - analysis.output_minus)
    ax4.legend(('input', 'output'), loc=(.05, .1))
    ax4.set_ylim(float(-source.amplitude * 1.1), float(source.amplitude * 1.1))

    plt.tight_layout()

    return circuit, analysis, plt
Example #7
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)]
Example #8
0
 def test_subcircuit(self):
     circuit = Circuit('')
     circuit.include('.../mosdriver.lib')
     circuit.X('test', 'mosdriver', '0', '1', '2', '3', '4', '5')
     circuit.BehavioralSource('test',
                              '1',
                              '0',
                              voltage_expression='if(0, 0, 1)',
                              smoothbsrc=1)
     print(circuit)
Example #9
0
def step_resp(vpk_pk):
    vmax = vpk_pk / 2
    shutil.copyfile('PA13.LIB', '/tmp/PA13.LIB')
    shutil.copyfile('op27.cir', '/tmp/op27.cir')
    circuit = Circuit('Step Response')
    circuit.include('/tmp/PA13.LIB')
    circuit.include('/tmp/op27.cir')
    circuit.subcircuit(PA13Amplifier(Z_1, Z_2))
    circuit.subcircuit(OP27Amplifier(R_4, C_4))

    # V_Ir input
    circuit.PulseVoltageSource(
        'input',
        'vir',
        circuit.gnd,
        -vmax,
        vmax,
        pulse_width=0.05,  # 0.05s
        period=0.1,  # 0.1s, 10Hz
        rise_time=1e-9,
        fall_time=1e-9)  # From lab provided schematic
    circuit.R('r3', 'vir', 'vir2', Z_3)
    # Current controller stage
    circuit.X('curr', 'op27_amplifier', 'vir2', 'vr')
    # Voltage stage
    circuit.X('volt', 'pa13_amplifier', 'vr', 'vo')
    # Motor stage
    circuit.R('rm', 'vo', 'vm1', R_m)
    circuit.L('lm', 'vm1', 'vio', L_m)

    circuit.R('rs', 'vio', circuit.gnd, R_s)
    circuit.R('r5', 'vio', 'vir2', Z_5)

    simulator = circuit.simulator()
    # Force ngspice to have shorter time steps near sharp transitions
    simulator.options(trtol=0.00001)
    import pdb
    pdb.set_trace()
    analysis = simulator.transient(
        step_time=0.1,  # Lab schematic suggests 0.1s, this seems too slow
        end_time=0.045
    )  # Lab schematic stops at 1s, we only need the first step
    return analysis
Example #10
0
 def register_subcircuit_instance(circuit: SpiceCircuit, inst: pya.Circuit):
     """
     Create a SPICE instance of the KLayout subcircuit instance `inst`.
     :param circuit: PySpice circuit to add the subcircuit instance ('X').
     :param inst: KLayout circuit instance.
     :return:
     """
     ref = inst.circuit_ref()
     name = ref.name
     num_pins = ref.pin_count()
     pin_nets = [inst.net_for_pin(i) for i in range(num_pins)]
     pin_names = [get_net_name(pin_net) for pin_net in pin_nets]
     circuit.X('{}'.format(inst.id()), name, *pin_names)
Example #11
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
Example #12
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)]
Example #13
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
Example #14
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]
Example #15
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')
Example #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'])))]
Example #17
0
def operational_amplifier():
    circuit = Circuit('Operational Amplifier')
    # AC 1 PWL(0US 0V  0.01US 1V)
    circuit.SinusoidalVoltageSource('input',
                                    'in',
                                    circuit.gnd,
                                    amplitude=10000000 @ u_V)
    circuit.subcircuit(BasicOperationalAmplifier())
    circuit.X('op', 'BasicOperationalAmplifier', 'in', circuit.gnd, 'out')
    circuit.R('load', 'out', circuit.gnd, 470 @ u_Ω)
    circuit.R(
        'R1',
        'in',
        'out',
    )

    simulator = circuit.simulator(temperature=25, nominal_temperature=25)
    analysis = simulator.ac(start_frequency=1 @ u_Hz,
                            stop_frequency=100 @ u_MHz,
                            number_of_points=5,
                            variation='dec')
    plt.close('all')
    figure, (ax1, ax2) = plt.subplots(2, figsize=(20, 10))

    plt.title("Bode Diagram of an Operational Amplifier")
    bode_diagram(
        axes=(ax1, ax2),
        frequency=analysis.frequency,
        gain=20 * np.log10(np.absolute(analysis.out)),
        phase=np.angle(analysis.out, deg=False),
        marker='.',
        color='blue',
        linestyle='-',
    )

    return circuit, analysis, plt
Example #18
0
class Level1(SubCircuitFactory):
    __name__ = 'level1'
    __nodes__ = ('d3', 'g3', 'v3')

    def __init__(self):
        super().__init__()
        self.X('mos2', 'level2', 'd3', 'g3', 'v3')
        self.subcircuit(Level2())


circuit = Circuit('Transistor output characteristics')
circuit.V('dd', 'd1', circuit.gnd, 2)
circuit.V('ss', 'vsss', circuit.gnd, 0)
circuit.V('sig', 'g1', 'vsss', 0)
circuit.X('mos1', 'level1', 'd1', 'g1', 'vsss')

if True:
    circuit.subcircuit(Level1())
else:
    subcircuit_level2 = SubCircuit('level2', 'd4', 'g4', 'v4')
    subcircuit_level2.M(1,
                        'd4',
                        'g4',
                        'v4',
                        'v4',
                        model='nmos',
                        w=1e-5,
                        l=3.5e-7)

    subcircuit_level1 = SubCircuit('level1', 'd3', 'g3', 'v3')
Example #19
0
circuit.R('in', 'in', 1, 50)
circuit.R('carrier', 'carrier', 2, 50)

circuit.include(spice_library['1N4148'])
circuit.subcircuit(
    RingModulator(
        outer_inductance=micro(1),
        inner_inductance=micro(1),
        coupling=.99,
        diode_model='1N4148',
    ))
circuit.X(
    'ring_modulator',
    'RingModulator',
    1,
    circuit.gnd,
    2,
    circuit.gnd,
    'output',
    circuit.gnd,
)

# outer_inductance = .01
# inner_inductance = .0025
# coupling = .9
# diode_model = '1N4148'
# input_inductor = circuit.L('input', 1, circuit.gnd, outer_inductance)
# top_inductor = circuit.L('input_top', 'input_top', 'carrier', inner_inductance)
# bottom_inductor = circuit.L('input_bottom', 'input_bottom', 'carrier', inner_inductance)
# circuit.CoupledInductor('input_top', input_inductor.name, top_inductor.name, coupling)
# circuit.CoupledInductor('input_bottom', input_inductor.name, bottom_inductor.name, coupling)
# circuit.X('D1', diode_model, 'input_top', 'output_top')
Example #20
0
def mkschematic(ind, nnodes, nodelist, spice_library):
    circuit = Circuit('generated circuit')

    circuit.V('vcc', 'vcc', circuit.gnd, '5V')
    circuit.V('vdd', 'vdd', circuit.gnd, '-5V')
    circuit.Sinusoidal('input', 'vin', circuit.gnd, amplitude=5)

    nodes = 0
    for i in range(nnodes):
        if ind[5 * i] == 1:
            circuit.R(
                nodes,
                nodelist[ind[5 * i +
                             2]] if ind[5 * i + 2] != 0 else circuit.gnd,
                nodelist[ind[5 * i +
                             3]] if ind[5 * i + 3] != 0 else circuit.gnd,
                values.E12R[ind[5 * i + 1]])
        elif ind[5 * i] == 2:
            circuit.C(
                nodes,
                nodelist[ind[5 * i +
                             2]] if ind[5 * i + 2] != 0 else circuit.gnd,
                nodelist[ind[5 * i +
                             3]] if ind[5 * i + 3] != 0 else circuit.gnd,
                values.E12C[ind[5 * i + 1]])
        elif ind[5 * i] == 3:
            circuit.include(spice_library['2n2222a'])
            circuit.BJT(
                nodes,
                nodelist[ind[5 * i +
                             2]] if ind[5 * i + 2] != 0 else circuit.gnd,
                nodelist[ind[5 * i +
                             3]] if ind[5 * i + 3] != 0 else circuit.gnd,
                nodelist[ind[5 * i +
                             4]] if ind[5 * i + 4] != 0 else circuit.gnd,
                '2n2222a')
        elif ind[5 * i] == 4:
            circuit.include(spice_library['2n2907'])
            circuit.BJT(
                nodes,
                nodelist[ind[5 * i +
                             2]] if ind[5 * i + 2] != 0 else circuit.gnd,
                nodelist[ind[5 * i +
                             3]] if ind[5 * i + 3] != 0 else circuit.gnd,
                nodelist[ind[5 * i +
                             4]] if ind[5 * i + 4] != 0 else circuit.gnd,
                '2n2907')
        elif ind[5 * i] == 6:
            circuit.include(spice_library['1N4148'])
            circuit.X(
                'D{}'.format(nodes), '1N4148',
                nodelist[ind[5 * i +
                             2]] if ind[5 * i + 2] != 0 else circuit.gnd,
                nodelist[ind[5 * i +
                             3]] if ind[5 * i + 3] != 0 else circuit.gnd)
        elif ind[5 * i] == 5:
            circuit.L(
                nodes,
                nodelist[ind[5 * i +
                             2]] if ind[5 * i + 2] != 0 else circuit.gnd,
                nodelist[ind[5 * i +
                             3]] if ind[5 * i + 3] != 0 else circuit.gnd,
                values.E12I[ind[5 * i + 1]])
        elif ind[5 * i] == 0:
            continue
        else:
            continue
        nodes += 1
    print(circuit)
Example #21
0
import datetime
sim_start_time = datetime.datetime.now()
print()
print('Simulation Start Time =', sim_start_time)
print()
####################################################################################################

#?# circuit_macros('buck-converter.m4')

circuit = Circuit('Buck Converter')

# Note that PySpice will parse ALL *.lib in the directory, even if they are not included, so keep extra .libs out
# the directory where the .lib files are called from is specified in 'libraries_path' (line 327 above)
circuit.include(spice_library['buck_netlist_simple'])
# Top level circuit annotated as "x1"
circuit.X(1, 'buck_netlist_simple', 'vin', 'gate_drive', 'output_v', 'sw_node')

Vin = 12 @ u_V
# Vout = 6@u_V
# ratio = Vout / Vin

# frequency = 400@u_kHz
# period = 2.5@u_us
# duty_cycle = 1.25@u_us

# Create input voltage to send to netlist
circuit.V('input', 'vin', circuit.gnd, Vin)

#####
# Simulation parameters
#####
Example #22
0
    def generate_and_test(self, gui, ind):
        circuit = Circuit('generated circuit')
        sys.stdout.write('  {:.1%}%\b\r'.format(self.GENCOUNTER /
                                                self.POPSIZE))
        sys.stdout.flush()

        circuit.V('vcc', 'vcc', circuit.gnd, '5V')
        circuit.V('vdd', 'vdd', circuit.gnd, '-5V')
        circuit.Sinusoidal('input', 'vin', circuit.gnd, amplitude=2)

        nodes = 0
        try:
            for i in range(self.N_NODES):
                if ind[5 * i] == 1:
                    circuit.R(
                        nodes, self.NODELIST[ind[5 * i + 2]]
                        if ind[5 * i + 2] != 0 else circuit.gnd,
                        self.NODELIST[ind[5 * i + 3]] if ind[5 * i + 3] != 0
                        else circuit.gnd, values.E12R[ind[5 * i + 1]])
                elif ind[5 * i] == 2:
                    circuit.C(
                        nodes, self.NODELIST[ind[5 * i + 2]]
                        if ind[5 * i + 2] != 0 else circuit.gnd,
                        self.NODELIST[ind[5 * i + 3]] if ind[5 * i + 3] != 0
                        else circuit.gnd, values.E12C[ind[5 * i + 1]])
                elif ind[5 * i] == 3:
                    circuit.include(self.spice_library['2n2222a'])
                    circuit.BJT(
                        nodes, self.NODELIST[ind[5 * i + 2]]
                        if ind[5 * i + 2] != 0 else circuit.gnd,
                        self.NODELIST[ind[5 * i + 3]] if ind[5 * i + 3] != 0
                        else circuit.gnd, self.NODELIST[ind[5 * i + 4]]
                        if ind[5 * i + 4] != 0 else circuit.gnd, '2n2222a')
                elif ind[5 * i] == 4:
                    circuit.include(self.spice_library['2n2907'])
                    circuit.BJT(
                        nodes, self.NODELIST[ind[5 * i + 2]]
                        if ind[5 * i + 2] != 0 else circuit.gnd,
                        self.NODELIST[ind[5 * i + 3]] if ind[5 * i + 3] != 0
                        else circuit.gnd, self.NODELIST[ind[5 * i + 4]]
                        if ind[5 * i + 4] != 0 else circuit.gnd, '2n2907')
                elif ind[5 * i] == 6:
                    circuit.include(self.spice_library['1N4148'])
                    circuit.X(
                        'D{}'.format(nodes), '1N4148',
                        self.NODELIST[ind[5 * i + 2]] if ind[5 * i + 2] != 0
                        else circuit.gnd, self.NODELIST[ind[5 * i + 3]]
                        if ind[5 * i + 3] != 0 else circuit.gnd)
                elif ind[5 * i] == 5:
                    circuit.L(
                        nodes, self.NODELIST[ind[5 * i + 2]]
                        if ind[5 * i + 2] != 0 else circuit.gnd,
                        self.NODELIST[ind[5 * i + 3]] if ind[5 * i + 3] != 0
                        else circuit.gnd, values.E12I[ind[5 * i + 1]])
                elif ind[5 * i] == 0:
                    continue
                else:
                    continue
                nodes += 1
            simulator = circuit.simulator(temperature=25,
                                          nominal_temperature=25)
            analysis = simulator.transient(start_time="2ms",
                                           step_time='1ms',
                                           end_time='40ms',
                                           max_time='40ms ')
        except:
            self.DEAD += 1
            self.s['pop'][self.s['counter']] = [self.GEN, -1, self.GENCOUNTER]
            self.s['counter'] += 1
            self.GENCOUNTER += 1
            return (-1., )
        result = 0
        try:
            j = 0.
            for n, m in zip(analysis.nodes['vin'][1:-1],
                            analysis.nodes['out'][1:-1]):
                j += self.toolbox.evaluator(n, m)
            result = (j / max([
                len(analysis.nodes['out'][1:-1]),
                len(analysis.nodes['out'][1:-1])
            ])) * (1 + 0.01 * (self.N_NODES - nodes))
            if result > 0 and gui != None:
                gui.dc.update_data(result, analysis.nodes['out'][1:-1],
                                   analysis.nodes['vin'][1:-1])
            self.s['pop'][self.s['counter']] = [
                self.GEN, result, self.GENCOUNTER
            ]
            self.GENCOUNTER += 1
            self.s['counter'] += 1
            return (result if result > 0 else 0, )
        except:
            self.s['pop'][self.s['counter']] = [
                self.GEN, -0.5, self.GENCOUNTER
            ]
            self.s['counter'] += 1
            self.GENCOUNTER += 1
            return (-0.5, )
Example #23
0
spice_library = SpiceLibrary(libraries_path)

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

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

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

circuit = Circuit('half-wave rectification')
circuit.include(spice_library['1N4148'])
source = circuit.Sinusoidal('input',
                            'in',
                            circuit.gnd,
                            amplitude=10 @ u_V,
                            frequency=50 @ u_Hz)
circuit.X('D1', '1N4148', 'in', 'output')
circuit.R('load', 'output', circuit.gnd, 100 @ u_Ω)

simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.transient(step_time=source.period / 200,
                               end_time=source.period * 2)

axe = plt.subplot(221)
plt.title('Half-Wave Rectification')
plt.xlabel('Time [s]')
plt.ylabel('Voltage [V]')
plt.grid()
plot(analysis['in'], axis=axe)
plot(analysis.output, axis=axe)
plt.legend(('input', 'output'), loc=(.05, .1))
plt.ylim(float(-source.amplitude * 1.1), float(source.amplitude * 1.1))
Example #24
0
Cin = Cin.canonise()

print('L =', L)
print('Cout =', Cout)
print('Cint =', Cin)

circuit.V('in', 'in', circuit.gnd, Vin)
circuit.C('in', 'in', circuit.gnd, Cin)

# Fixme: out drop from 12V to 4V
# circuit.VCS('switch', 'gate', circuit.gnd, 'in', 'source', model='Switch', initial_state='off')
# circuit.Pulse('pulse', 'gate', circuit.gnd, 0@u_V, Vin, duty_cycle, period)
# circuit.model('Switch', 'SW', ron=1@u_mΩ, roff=10@u_MΩ)

# Fixme: Vgate => Vout ???
circuit.X('Q', 'irf150', 'in', 'gate', 'source')
# circuit.Pulse('pulse', 'gate', 'source', 0@u_V, Vin, duty_cycle, period)
circuit.R('gate', 'gate', 'clock', 1 @ u_Ω)
circuit.Pulse('pulse', 'clock', circuit.gnd, 0 @ u_V, 2. * Vin, duty_cycle,
              period)

circuit.X('D', '1N5822', circuit.gnd, 'source')
circuit.L(1, 'source', 1, L)
circuit.R('L', 1, 'out', RL)
circuit.C(1, 'out', circuit.gnd, Cout)  # , initial_condition=0@u_V
circuit.R('load', 'out', circuit.gnd, Rload)

simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.transient(step_time=period / 300, end_time=period * 150)

figure = plt.figure(1, (20, 10))
Example #25
0
circuit.include(spice_library['1N4148'])
source = circuit.SinusoidalVoltageSource('input',
                                         'in',
                                         circuit.gnd,
                                         amplitude=10 @ u_V,
                                         frequency=50 @ u_Hz)

multiplier = 5
for i in range(multiplier):
    if i:
        top_node = i - 1
    else:
        top_node = 'in'
    midlle_node, bottom_node = i + 1, i
    circuit.C(i, top_node, midlle_node, 1 @ u_mF)
    circuit.X(i, '1N4148', midlle_node, bottom_node)
circuit.R(1, multiplier, multiplier + 1, 1 @ u_MΩ)

simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.transient(step_time=source.period / 200,
                               end_time=source.period * 20)

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

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

axe = plt.subplot(111)
axe.set_title('Voltage Multiplier')
axe.set_xlabel('Time [s]')
axe.set_ylabel('Voltage [V]')
axe.grid()
Example #26
0
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *

libraries_path = find_libraries()
spice_library = SpiceLibrary(libraries_path)

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

circuit = Circuit('half-wave rectification')
circuit.include(spice_library['1N4148'])
source = circuit.SinusoidalVoltageSource('input',
                                         'in',
                                         circuit.gnd,
                                         amplitude=10 @ u_V,
                                         frequency=50 @ u_Hz)
circuit.X('D1', '1N4148', 'in', 'output')
circuit.R('load', 'output', circuit.gnd, 100 @ u_Ω)

simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.transient(step_time=source.period / 200,
                               end_time=source.period * 2)

axe = plt.subplot(221)
plt.title('Half-Wave Rectification')
plt.xlabel('Time [s]')
plt.ylabel('Voltage [V]')
plt.grid()
plot(analysis['in'], axis=axe)
plot(analysis.output, axis=axe)
plt.legend(('input', 'output'), loc=(.05, .1))
plt.ylim(float(-source.amplitude * 1.1), float(source.amplitude * 1.1))
Example #27
0
from circuit_components import ParallelResistor
from PySpice.Spice.Netlist import Circuit, SubCircuit
from PySpice.Unit import *

circuit = Circuit('Test')

circuit.subcircuit(ParallelResistor(R2=3 @ u_Ω))
circuit.X('1', 'parallel_resistor', 1, circuit.gnd)

print(circuit)
Example #28
0
                                            'Out',
                                            'vp+',
                                            'vp-',
                                            transconductance='{Gain}')


#Definition of the LSST thermal model circuit - One RAFT
circuit = Circuit("MainCryo")

#PI regulators
circuit.subcircuit(PI())
circuit.X(1,
          'PI',
          'CCDSetPoint',
          'L3_CCD',
          'HeaterCtrl',
          K=par.KG1,
          KI=par.KIG1,
          AWG=par.AWG1,
          MINV=par.MING1,
          MAXV=par.MAXG1)
circuit.X(2,
          'PI',
          'PlateSetPoint',
          'CryoPlate',
          'PlateCtrl',
          K=par.KG2,
          KI=par.KIG2,
          AWG=par.AWG2,
          MINV=par.MING2,
          MAXV=par.MAXG2)
circuit.X(3,
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

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

#!# We plot the characteristic curve and compare it to the Shockley diode model:
#!#
Example #30
0
D3 N003 A Def
D4 N003 0 Deg
R1 N001 N002 27.5
L1 N002 N003 0.5
.MODEL Def D
'''

circuit.SinusoidalVoltageSource('1',
                                'A',
                                circuit.gnd,
                                amplitude=220,
                                frequency=50)

subcir = BasicNonLinearLoad(r=27.5, l=0.5)
circuit.subcircuit(subcir)
circuit.X('1', 'BasicNonLinearLoad', 'A', circuit.gnd)

print(circuit)

print(subcir.getRValue())
print(subcir.getLValue())

simulator = circuit.simulator()
#enableLtSpice(simulator)
analysis = simulator.transient(step_time=1 @ u_ms, end_time=1 @ u_s)

current = analysis['V1']
aimax = np.amax(current.data)
aimin = np.amin(current.data)
print('Max Current: ', aimax)
print('Min Current: ', aimin)