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(-source.amplitude * 1.1, source.amplitude * 1.1) #################################################################################################### #cm# half-wave-rectification.m4 circuit.C('1', 'output', circuit.gnd, milli(1)) simulator = circuit.simulator(temperature=25, nominal_temperature=25) analysis = simulator.transient(step_time=source.period / 200, end_time=source.period * 2) axe = plt.subplot(222) plt.title('Half-Wave Rectification with filtering') 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(-source.amplitude * 1.1, source.amplitude * 1.1)
from PySpice.Unit import * #################################################################################################### libraries_path = find_libraries() spice_library = SpiceLibrary(libraries_path) #################################################################################################### #f# circuit_macros('ac-coupled-amplifier.m4') circuit = Circuit('Transistor') circuit.V('power', 5, circuit.gnd, 15@u_V) source = circuit.SinusoidalVoltageSource('in', 'in', circuit.gnd, amplitude=.5@u_V, frequency=1@u_kHz) circuit.C(1, 'in', 2, 10@u_uF) circuit.R(1, 5, 2, 100@u_kΩ) circuit.R(2, 2, 0, 20@u_kΩ) circuit.R('C', 5, 4, 10@u_kΩ) 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.R('E', 3, 0, 2@u_kΩ) circuit.C(2, 4, 'out', 10@u_uF) circuit.R('Load', 'out', 0, 1@u_MΩ) #################################################################################################### figure = plt.figure(1, (20, 10)) # .ac dec 5 10m 1G
#f# circuit_macros('capacitive-half-wave-rectification-post-zener-circuit.m4') circuit = Circuit('Capacitive Half-Wave Rectification (Post Zener)') circuit.include(spice_library['1N4148']) # 1N5919B: 5.6 V, 3.0 W Zener Diode Voltage Regulator circuit.include(spice_library['d1n5919brl']) ac_line = circuit.AcLine('input', circuit.gnd, 'L', rms_voltage=230 @ u_V, frequency=50 @ u_Hz) circuit.R('in', 'L', 1, 470 @ u_Ω) circuit.C('in', 1, 2, 470 @ u_nF) circuit.X('Dz', 'd1n5919brl', circuit.gnd, 2) circuit.X('D', '1N4148', 2, 'out') circuit.C('', circuit.gnd, 'out', 220 @ u_uF) circuit.R('load', circuit.gnd, 'out', 1 @ u_kΩ) #?# Fixme: circuit.nodes[2].v, circuit.branch.current # print circuit.nodes # Simulator(circuit, ...).transient(...) simulator = circuit.simulator(temperature=25, nominal_temperature=25) analysis = simulator.transient(step_time=ac_line.period / 200, end_time=ac_line.period * 10) figure = plt.figure(1, (20, 10)) axe = plt.subplot(111)
ripple_current_in = Iload / 2 ripple_voltage_in = 200 @ u_mV ESR_in = 120 @u_mΩ Cin = duty_cycle / (ripple_voltage_in / ripple_current_in - ESR_in) L = L.canonise() Cout = Cout.canonise() 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.PulseVoltageSource('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.PulseVoltageSource('pulse', 'gate', 'source', 0@u_V, Vin, duty_cycle, period) circuit.R('gate', 'gate', 'clock', 1 @ u_Ω) circuit.PulseVoltageSource('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)
def spice_circuit(self, amplitude=1, frequency=0, initial_condition=0): self.amplitude = amplitude self.frequency = frequency circuit = Circuit('Battery Equivalent model') circuit.V('OCV', 1, circuit.gnd, self.Voc @ u_V) #name,positive node,negative node,value circuit.R( 'Rs', 1, 'cap_input_voltage', self.Rs @ u_Ω) #node 2='source_input_node' and node 3='source_output_node' circuit.R('Rp', 'cap_input_voltage', 'cap_output_voltage', self.Rp @ u_Ω) circuit.C('Cp', 'cap_input_voltage', 'cap_output_voltage', self.Cp @ u_F, ic=0 @ u_V) #ic=initial condition circuit.R('Rl', 'cap_output_voltage', 'source_input_node', self.Rl @ u_Ω) #Rl=0 #print(circuit) if self.frequency == 0: circuit.I('current_source', 'source_input_node', circuit.gnd, self.amplitude @ u_A) else: circuit.SinusoidalCurrentSource( 'current_source', 'source_input_node', circuit.gnd, 0 @ u_A, offset=0 @ u_A, amplitude=self.amplitude @ u_A, frequency=self.frequency @ u_Hz) #freq=0.4 #ac_line = circuit.AcLine('current_source', 'source_input_node','source_output_node' , frequenc=0.4u_Hz) #print(circuit) print(initial_condition) simulator = circuit.simulator(temperature=25, nominal_temperature=25) simulator.initial_condition(cap_input_voltage=initial_condition @ u_V) analysis = simulator.transient( step_time=0.01 @ u_s, end_time=1 @ u_s) #@u_s is sec and @u_us is micro sec output_node = [] input_node = [] for node in (analysis['cap_output_voltage']): # #print('Node {}: {} V'.format(str(node), float(node))) output_node.append(float(node)) # print(output_node) for node in (analysis['cap_input_voltage']): # #print('Node {}: {} V'.format(str(node), float(node))) input_node.append(float(node)) # ============================================================================= # print("output_node - input_node : ",input_node[100]-output_node[100]) # print("output_node ",output_node[100]) # print("input ",input_node[100]) # print("output_node shape ",len(output_node)) # ============================================================================= # ============================================================================= # figure1, ax = plt.subplots(figsize=(20, 10)) # ax.set_title('Battery Equivalent Model') # ax.set_xlabel('Time [s]') # ax.set_ylabel('Voltage [V]') # ax.grid() # ax.plot(analysis.cap_input_voltage-analysis.cap_output_voltage) # #ax.plot(analysis.cap_input_voltage) # ============================================================================= Vb = output_node[100] Vb = np.random.normal(Vb, scale=math.sqrt(self.observation_noise)) return ( Vb, input_node[100] - output_node[100] ) #at every 1 we are returning the output value 100*step_time=1sec,in array it will be 99th value100*step_time=0.1 sec,in array it will be 99th value
#################################################################################################### from PySpice.Plot.BodeDiagram import bode_diagram from PySpice.Spice.Netlist import Circuit from PySpice.Unit.Units import * #################################################################################################### circuit = Circuit('Four double-pole Low-Pass RLC Filter') circuit.Sinusoidal('input', 'in', circuit.gnd, amplitude=1) # pulse 0 5 10 ms # Q = .5 circuit.R(1, 'in', 2, 200) circuit.L(1, 2, 3, milli(10)) circuit.C(1, 3, circuit.gnd, micro(1)) # vout = 3 # Q = 1 circuit.R(2, 'in', 4, 100) circuit.L(2, 4, 5, milli(10)) circuit.C(2, 5, circuit.gnd, micro(1)) # Q = 2 circuit.R(3, 'in', 6, 50) circuit.L(3, 6, 7, milli(10)) circuit.C(3, 7, circuit.gnd, micro(1)) # Q = 4 circuit.R(4, 'in', 8, 25) circuit.L(4, 8, 9, milli(10)) circuit.C(4, 9, circuit.gnd, micro(1)) simulator = circuit.simulator(temperature=25, nominal_temperature=25) analysis = simulator.ac(start_frequency=100,
#f# literal_include('HP54501A.py') #################################################################################################### circuit = Circuit('HP54501A CEM') circuit.include(spice_library['1N4148']) diode_model = '1N4148' ac_line = circuit.AcLine('input', 'input', circuit.gnd, rms_voltage=230 @ u_V, frequency=50 @ u_Hz) # circuit.subcircuit(HP54501A(diode_model='1N4148')) # circuit.X('hp54501a', 'HP54501A', 'input', circuit.gnd) circuit.C(1, 'input', circuit.gnd, 1 @ u_uF) circuit.X('D1', diode_model, 'line_plus', 'top') circuit.X('D2', diode_model, 'scope_ground', 'input') circuit.X('D3', diode_model, circuit.gnd, 'top') circuit.X('D4', diode_model, 'scope_ground', circuit.gnd) circuit.R(1, 'top', 'output', 10 @ u_Ω) circuit.C(2, 'output', 'scope_ground', 50 @ u_uF) circuit.R(2, 'output', 'scope_ground', 900 @ u_Ω) simulator = circuit.simulator(temperature=25, nominal_temperature=25) analysis = simulator.transient(step_time=ac_line.period / 100, end_time=ac_line.period * 3) figure = plt.figure(None, (20, 6)) plot(analysis.input)
#################################################################################################### libraries_path = find_libraries() spice_library = SpiceLibrary(libraries_path) #################################################################################################### circuit = Circuit('STM AN1476: Low-Cost Power Supply For Home Appliances') circuit.include(spice_library['1N4148']) # 1N5919B: 5.6 V, 3.0 W Zener Diode Voltage Regulator circuit.include(spice_library['d1n5919brl']) ac_line = circuit.AcLine('input', 'out', 'in', rms_voltage=230, frequency=50) circuit.R('load', 'out', circuit.gnd, kilo(1)) circuit.C('load', 'out', circuit.gnd, micro(220)) circuit.X('D1', '1N4148', circuit.gnd, 1) circuit.D(1, circuit.gnd, 1, model='DIODE1', off=True) circuit.X('Dz1', 'd1n5919brl', 1, 'out') circuit.C('ac', 1, 2, nano(470)) circuit.R('ac', 2, 'in', 470) # Fixme: , m=1, temperature='{25}' source = str(circuit) print(source) #################################################################################################### parser = SpiceParser(source=source) bootstrap_circuit = parser.build_circuit() bootstrap_source = str(bootstrap_circuit)
logger = Logging.setup_logging() #################################################################################################### from PySpice.Plot.BodeDiagram import bode_diagram from PySpice.Spice.Netlist import Circuit from PySpice.Unit.Units import * #################################################################################################### circuit = Circuit('Low-Pass RC Filter') circuit.Sinusoidal('input', 'in', circuit.gnd, amplitude=1) circuit.R('f', 'in', 'out', kilo(1)) circuit.C('f', 'out', circuit.gnd, micro(1)) simulator = circuit.simulator(temperature=25, nominal_temperature=25) analysis = simulator.ac(start_frequency=1, stop_frequency=mega(1), number_of_points=10, variation='dec') print(analysis.out) figure = plt.figure(1, (20, 10)) plt.title("Bode Diagram of a Low-Pass RC Filter") bode_diagram( axes=(plt.subplot(211), plt.subplot(212)), frequency=analysis.frequency, gain=20 * np.log10(np.absolute(analysis.out)),
circuit = Circuit('Voltage Multiplier') circuit.include(spice_library['1N4148']) source = circuit.Sinusoidal('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]')
NAME = 'sub_circuit1' NODES = ('n1', 'n2') def __init__(self): super().__init__() self.R(1, 'n1', 'n2', 1 @ u_Ω) self.R(2, 'n1', 'n2', 2 @ u_Ω) #r# Let define a circuit. circuit = Circuit('Test') #r# When we add an element to a circuit, we can get a reference to it or ignore it: C1 = circuit.C(1, 0, 1, 1 @ u_uF) circuit.C(2, 1, 2, 2 @ u_uF) circuit.subcircuit(SubCircuit1()) circuit.X('1', 'sub_circuit1', 2, 0) #r# We can get back an element of a circuit using its name, either as a class attribute or using the #r# dictionary interface: C1 = circuit.C1 C1 = circuit['C1'] #r# and modify it C1.capacitance = 10 @ u_F
# Real analog stimuli from python code below: circuit.V('sense', 'sense_net', circuit.gnd, 'dc 0 external') circuit.V('sense2', 'sense_net_2', circuit.gnd, 'dc 0 external') # Other NGspice circuit parameters for filter stage # Cout = 22@u_uF # ESR = 20@u_mOhm # ESL = 0 # parameters on input to buck # circuit.V('input', 'input', circuit.gnd, Vin) # circuit.C('input', 'input', circuit.gnd, Cin) circuit.C(1, 'esr', circuit.gnd, 22 @ u_uF) # , initial_condition=0@u_V circuit.R(1, 'sense_net_2', 'esr', 10 @ u_Ohm) # This clock is used for NGspice mixed signal simulation. # The python code runs every clock edge, both positive and negative # clock speed: 2.5MHz # clock cycle length: 40ns circuit.PulseVoltageSource('clk', 'clk', circuit.gnd, 0 @ u_V, 1 @ u_V, 20 @ u_ns, 40 @ u_ns) ##### # Simulation parameters ##### # Python block input constants amplitude = 10 @ u_V
#################################################################################################### from PySpice.Plot.BodeDiagram import bode_diagram from PySpice.Spice.Netlist import Circuit from PySpice.Unit import * #################################################################################################### #f# circuit_macros('low-pass-rc-filter.m4') circuit = Circuit('Low-Pass RC Filter') circuit.SinusoidalVoltageSource('input', 'in', circuit.gnd, amplitude=1 @ u_V) R1 = circuit.R(1, 'in', 'out', 1 @ u_kΩ) C1 = circuit.C(1, 'out', circuit.gnd, 1 @ u_uF) #r# The break frequency is given by :math:`f_c = \frac{1}{2 \pi R C}` break_frequency = 1 / (2 * math.pi * float(R1.resistance * C1.capacitance)) print("Break frequency = {:.1f} Hz".format(break_frequency)) #o# simulator = circuit.simulator(temperature=25, nominal_temperature=25) analysis = simulator.ac(start_frequency=1 @ u_Hz, stop_frequency=1 @ u_MHz, number_of_points=10, variation='dec') # print(analysis.out) #r# We plot the Bode diagram.
#cm# capacitive-half-wave-rectification-post-zener-circuit.m4 circuit = Circuit('Capacitive Half-Wave Rectification (Post Zener)') circuit.include(spice_library['1N4148']) # 1N5919B: 5.6 V, 3.0 W Zener Diode Voltage Regulator circuit.include(spice_library['d1n5919brl']) ac_line = circuit.AcLine('input', circuit.gnd, 'L', rms_voltage=230, frequency=50) circuit.R('in', 'L', 1, 470) circuit.C('in', 1, 2, nano(470)) circuit.X('Dz', 'd1n5919brl', circuit.gnd, 2) circuit.X('D', '1N4148', 2, 'out') circuit.C('', circuit.gnd, 'out', micro(220)) circuit.R('load', circuit.gnd, 'out', kilo(1)) # # Fixme: circuit.nodes[2].v, circuit.branch.current # print circuit.nodes # Simulator(circuit, ...).transient(...) simulator = circuit.simulator(temperature=25, nominal_temperature=25) analysis = simulator.transient(step_time=ac_line.period / 200, end_time=ac_line.period * 10) figure = plt.figure(1, (20, 10)) axe = plt.subplot(111)
libraries_path = find_libraries() spice_library = SpiceLibrary(libraries_path) #################################################################################################### #f# circuit_macros('capacitive-half-wave-rectification-pre-zener-circuit.m4') circuit = Circuit('Capacitive Half-Wave Rectification (Pre Zener)') circuit.include(spice_library['1N4148']) # 1N5919B: 5.6 V, 3.0 W Zener Diode Voltage Regulator circuit.include(spice_library['d1n5919brl']) ac_line = circuit.AcLine('input', circuit.gnd, 'L', rms_voltage=230 @ u_V, frequency=50 @ u_Hz) circuit.C('in', 'L', 1, 330 @ u_nF) circuit.R('emi', 'L', 1, 165 @ u_kΩ) circuit.R('in', 1, 2, 2 * 47 @ u_Ω) circuit.X('D1', '1N4148', 2, 'out') circuit.C('2', 'out', 3, 250 @ u_uF) circuit.R('2', 3, circuit.gnd, 1 @ u_kΩ) circuit.X('D2', '1N4148', 3, 2) circuit.X('Dz', 'd1n5919brl', circuit.gnd, 'out') circuit.C('', circuit.gnd, 'out', 250 @ u_uF) circuit.R('load', circuit.gnd, 'out', 1 @ u_kΩ) #?# Fixme: circuit.nodes[2].v, circuit.branch.current # print circuit.nodes # Simulator(circuit, ...).transient(...) simulator = circuit.simulator(temperature=25, nominal_temperature=25)
circuit.gnd, amplitude=Vp, frequency=Vf) circuit.L('L_hub', 'in', 'L_hub_out', Lh) circuit.R('R_hub', 'L_hub_out', 'bridge_in_plus', Rh) circuit.R('R_hub_parasitic', 'L_hub_out', circuit.gnd, Rhp) # bridge rectifier circuit.X('D1', '1N4148', 'bridge_in_plus', 'output_plus') circuit.X('D2', '1N4148', 'output_minus', circuit.gnd) circuit.X('D3', '1N4148', circuit.gnd, 'output_plus') circuit.X('D4', '1N4148', 'output_minus', 'bridge_in_plus') # load and filter cap circuit.X('load', 'CONSTANT_POWER_LOAD', 'output_plus', 'output_minus', P=Pl) circuit.C('1', 'output_plus', 'output_minus', C, initial_condition=10 @ u_V) simulator = circuit.simulator(temperature=25, nominal_temperature=25) analysis = simulator.transient(step_time=source.period / 2000, end_time=source.period * 20, use_initial_condition=True) axe = plt.subplot(111) plt.title('Dynamo Hub LED Driver\nRegulator Modeled As Constant Power Load') plt.xlabel('Time [s]') plt.ylabel('Voltage [V]') plt.grid() plot(analysis['in'], axis=axe) plot(analysis.output_plus - analysis.output_minus, axis=axe, linewidth=2.0)
circuit = Circuit('Voltage Multiplier') circuit.include(spice_library['1N4148']) source = circuit.Sinusoidal('input', 'in', circuit.gnd, amplitude=10, frequency=50) 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, milli(1)) circuit.X(i, '1N4148', midlle_node, bottom_node) circuit.R(1, multiplier, multiplier + 1, mega(1)) 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 = 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)) #################################################################################################### #f# circuit_macros('half-wave-rectification.m4') circuit.C('1', 'output', circuit.gnd, 1 @ u_mF) simulator = circuit.simulator(temperature=25, nominal_temperature=25) analysis = simulator.transient(step_time=source.period / 200, end_time=source.period * 2) axe = plt.subplot(222) plt.title('Half-Wave Rectification with filtering') 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))
#################################################################################################### 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)', table=((-micro(1), 0), (micro(1), source.dc_value)) ) simulator = circuit.simulator(temperature=25, nominal_temperature=25)
from PySpice.Plot.BodeDiagram import bode_diagram from PySpice.Spice.Netlist import Circuit from PySpice.Unit import * circuit1 = Circuit('Four double-pole Low-Pass RLC Filter') inductance = 10@u_mH capacitance = 1@u_uF circuit1.SinusoidalVoltageSource('input', 'in', circuit1.gnd, amplitude=1@u_V) # Q = .5 circuit1.R(1, 'in', 1, 200@u_Ω) circuit1.L(1, 1, 'out5', inductance) circuit1.C(1, 'out5', circuit1.gnd, capacitance) # Q = 1 circuit1.R(2, 'in', 2, 100@u_Ω) circuit1.L(2, 2, 'out1', inductance) circuit1.C(2, 'out1', circuit1.gnd, capacitance) # Q = 2 circuit1.R(3, 'in', 3, 50@u_Ω) circuit1.L(3, 3, 'out2', inductance) circuit1.C(3, 'out2', circuit1.gnd, capacitance) # Q = 4 R4 = circuit1.R(4, 'in', 4, 25@u_Ω) circuit1.L(4, 4, 'out4', inductance) circuit1.C(4, 'out4', circuit1.gnd, capacitance) simulator1 = circuit1.simulator(temperature=25, nominal_temperature=25) analysis1 = simulator1.ac(start_frequency=100@u_Hz, stop_frequency=10@u_kHz, number_of_points=100, variation='dec')
#################################################################################################### #f# circuit_macros('low-pass-rc-filter.m4') circuit = Circuit('Low-Pass RC Filter') circuit.SinusoidalVoltageSource('input', 'in', circuit.gnd, amplitude=1 @ u_V) Rs0 = 5 R1 = 50 C1 = 0.5 Rt0 = 5 Rs = circuit.R('s', 'in', 1, Rs0 @ u_Ω) R1 = circuit.R(1, 1, 2, R1 @ u_Ω) C1 = circuit.C(1, 2, circuit.gnd, C1 @ u_pF) Rt = circuit.R('t', 2, circuit.gnd, Rt0 @ u_Ω) #r# The break frequency is given by :math:`f_c = \frac{1}{2 \pi R C}` break_frequency = 1 / (2 * math.pi * float(R1.resistance * C1.capacitance)) print("Break frequency = {:.1f} Hz".format(break_frequency)) #o# simulator = circuit.simulator(temperature=25, nominal_temperature=25) analysis = simulator.ac(start_frequency=1e8 @ u_Hz, stop_frequency=5e10 @ u_Hz, number_of_points=100, variation='dec') # print(analysis.out)
def define_circuit(self): logger = Logging.setup_logging() circuit_lab = self.circuit circuit = Circuit(circuit_lab["name"]) # for complex circuit elements that requires SPICE library # libraries_path = find_libraries() python_file = os.path.abspath(sys.argv[0]) examples_root = parent_directory_of(python_file) libraries_path = os.path.join(examples_root, 'libraries') spice_library = SpiceLibrary(libraries_path) # return message message = "" # add all elements to the PySpice circuit for element in circuit_lab: if element == "V": for dc_voltage_source in circuit_lab["V"]: circuit.V( dc_voltage_source["id"], circuit.gnd if dc_voltage_source["node1"] == "gnd" else dc_voltage_source["node1"], circuit.gnd if dc_voltage_source["node2"] == "gnd" else dc_voltage_source["node2"], dc_voltage_source["value"] @ u_V) elif element == "VA": for ac_voltage_source in circuit_lab["VA"]: circuit.SinusoidalVoltageSource( ac_voltage_source["id"], circuit.gnd if ac_voltage_source["node1"] == "gnd" else ac_voltage_source["node1"], circuit.gnd if ac_voltage_source["node2"] == "gnd" else ac_voltage_source["node2"], amplitude=ac_voltage_source["amplitude"] @ u_V, frequency=ac_voltage_source["frequency"] @ u_Hz, offset=ac_voltage_source["offset"] @ u_V) elif element == "I": for dc_current_source in circuit_lab["I"]: circuit.I( dc_current_source["id"], circuit.gnd if dc_current_source["node1"] == "gnd" else dc_current_source["node1"], circuit.gnd if dc_current_source["node2"] == "gnd" else dc_current_source["node2"], dc_current_source["value"] @ u_A) elif element == "IA": for ac_current_source in circuit_lab["IA"]: circuit.SinusoidalCurrentSource( ac_current_source["id"], circuit.gnd if ac_current_source["node1"] == "gnd" else ac_current_source["node1"], circuit.gnd if ac_current_source["node2"] == "gnd" else ac_current_source["node2"], amplitude=ac_current_source["amplitude"] @ u_A, frequency=ac_current_source["frequency"] @ u_Hz, offset=ac_current_source["offset"] @ u_A) elif element == "R": for resistor in circuit_lab["R"]: circuit.R( resistor["id"], circuit.gnd if resistor["node1"] == "gnd" else resistor["node1"], circuit.gnd if resistor["node2"] == "gnd" else resistor["node2"], resistor["value"] @ u_Ω) elif element == "L": for inductor in circuit_lab["L"]: circuit.L( inductor["id"], circuit.gnd if inductor["node1"] == "gnd" else inductor["node1"], circuit.gnd if inductor["node2"] == "gnd" else inductor["node2"], inductor["value"] @ u_H) elif element == "C": for capacitor in circuit_lab["C"]: circuit.C( capacitor["id"], circuit.gnd if capacitor["node1"] == "gnd" else capacitor["node1"], circuit.gnd if capacitor["node2"] == "gnd" else capacitor["node2"], capacitor["value"] @ u_F) elif element == "D": for diode in circuit_lab["D"]: try: circuit.include(spice_library[diode["modelType"]]) circuit.X( diode["id"], diode["modelType"], circuit.gnd if diode["node1"] == "gnd" else diode["node1"], circuit.gnd if diode["node2"] == "gnd" else diode["node2"]) except KeyError as e: message += " " + str(e) elif element == "nBJT": for nBJT in circuit_lab["nBJT"]: try: circuit.include(spice_library[nBJT["modelType"]]) circuit.BJT(nBJT["id"], circuit.gnd if nBJT["node1"] == "gnd" else nBJT["node1"], circuit.gnd if nBJT["node2"] == "gnd" else nBJT["node2"], circuit.gnd if nBJT["node3"] == "gnd" else nBJT["node3"], model=nBJT["modelType"]) except KeyError as e: message += " " + str(e) elif element == "pBJT": for pBJT in circuit_lab["pBJT"]: try: circuit.include(spice_library[pBJT["modelType"]]) circuit.BJT(pBJT["id"], circuit.gnd if pBJT["node3"] == "gnd" else pBJT["node3"], circuit.gnd if pBJT["node2"] == "gnd" else pBJT["node2"], circuit.gnd if pBJT["node1"] == "gnd" else pBJT["node1"], model=pBJT["modelType"]) except KeyError as e: message += " " + str(e) elif element == "NMOS": for NMOS in circuit_lab["NMOS"]: try: circuit.include(spice_library[NMOS["modelType"]]) # nodes are: drain, gate, source, bulk circuit.MOSFET(NMOS["id"], circuit.gnd if NMOS["node4"] == "gnd" else NMOS["node4"], circuit.gnd if NMOS["node2"] == "gnd" else NMOS["node2"], circuit.gnd if NMOS["node3"] == "gnd" else NMOS["node3"], circuit.gnd if NMOS["node1"] == "gnd" else NMOS["node1"], model=NMOS["modelType"]) except KeyError as e: message += " " + str(e) elif element == "PMOS": for PMOS in circuit_lab["PMOS"]: try: circuit.include(spice_library[PMOS["modelType"]]) # nodes are: source, gate, drain, bulk circuit.MOSFET(PMOS["id"], circuit.gnd if PMOS["node1"] == "gnd" else PMOS["node1"], circuit.gnd if PMOS["node2"] == "gnd" else PMOS["node2"], circuit.gnd if PMOS["node3"] == "gnd" else PMOS["node3"], circuit.gnd if PMOS["node4"] == "gnd" else PMOS["node4"], model=PMOS["modelType"]) except KeyError as e: message += " " + str(e) # add ammeter as a 0 volt voltage source elif element == "AM": for ammeter in circuit_lab["AM"]: circuit.V( ammeter["id"], circuit.gnd if ammeter["node1"] == "gnd" else ammeter["node1"], circuit.gnd if ammeter["node2"] == "gnd" else ammeter["node2"], ammeter["value"] @ u_V) if not message: self.spice = circuit return message return "Undefined model type:" + message
TT=3.48E-9) # print str(subcircuit_1N4148) frequence = 50 perdiod = 1. / frequence step_time = perdiod / 200 end_time = perdiod * 10 line_peak_voltage = 10 circuit = Circuit('Simple Rectifier', global_nodes=(0, 'out')) circuit.subcircuit(subcircuit_1N4148) circuit.V('input', 'in', circuit.gnd, 'DC 0V', 'SIN(0V {}V {}Hz)'.format(line_peak_voltage, frequence)) circuit.X('D', '1N4148', 'in', 'out') circuit.C('load', 'out', circuit.gnd, micro(100)) circuit.R('load', 'out', circuit.gnd, kilo(1), ac='1k') circuit.Cload.plus.add_current_probe(circuit) simulation = circuit.simulation(temperature=25, nominal_temperature=25, pipe=True) simulation.options(filetype='binary') simulation.save('V(in)', 'V(out)') simulation.tran(step_time, end_time) print(circuit.nodes) for node in circuit.nodes: print(repr(node), ':', ' '.join(element.name for element in node.elements)) print(circuit.Cload.plus)
circuit = Circuit('Low-Pass RC Filter') circuit.SinusoidalVoltageSource('input', 'in', circuit.gnd, amplitude=1 @ u_V) Rs0 = 50 Rt0 = 25 circuit.R('s', 'in', 1, Rs0 @ u_Ω) n = 6 for i in range(1, n + 1): # Transmission line (Passive segment) circuit.R(i, (4 * i - 3), (4 * i), 1.65 @ u_Ω) circuit.L(i, (4 * i), (4 * i + 1), 1.27e-10 @ u_H) circuit.C(i, (4 * i + 1), circuit.gnd, 2.24e-14 @ u_F) circuit.R(i * 10, (4 * i + 1), circuit.gnd, 8e3 @ u_Ω) # Phase shifter (Active segment) Rs = 60 # 60 Cj = 82e-15 # 82e-15 circuit.R(i * 100, (4 * i + 1), (4 * i + 3), Rs @ u_Ω) circuit.C(i * 10, (4 * i + 3), circuit.gnd, Cj @ u_F) # mycircuit.add_resistor("Rsub%s" % (i), n1="n%s" %(4*i+1), n2="n%s" %(4*i+2), value=20.0) # mycircuit.add_capacitor("Cox%s" % (i), n1="n%s" %(4*i+2), n2=gnd, value=4.09e-14) circuit.R('t', (4 * i + 1), circuit.gnd, Rt0 @ u_Ω) #r# The break frequency is given by :math:`f_c = \frac{1}{2 \pi R C}`