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}`
