def test_transformer(self):
import os
from PySpice.Spice.Netlist import Circuit
circuit = Circuit('Diode Characteristic Curve')
circuit.L('primary', 'Vlp', 'Vdrain', '{l_trf}')
circuit.C('resonance', 'Vlv', 'Vdrain', '{cap_r}')
circuit.L('secondary', 'Vls', 'ghv', '{Ls}')
circuit.R('secondary', 'Vls', 1, 5.15)
circuit.K('flyback', 'Lprimary', 'Lsecondary', 1)
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
def simulate_RLC(w=2000,V=2,R=10,L=3,C=320,**kwargs):
circuit = Circuit('Name me please')
circuit.R('1', 1, 2,R@u_kΩ)
circuit.L('1', 2, 3,L@u_H)
circuit.C('1', 3, 0,C@u_nF)
#circuit.V('1', circuit.gnd,1 ,f'SIN(0 {V} {w})')
circuit.V('1',0,1, f'DC 0 AC {V} SIN(0 {V} {w})')
dt = 2*np.pi/w*4
tf = 5/w
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
#analysis = simulator.transient(step_time=0.1@u_ms, end_time=tf@u_s)
analysis = simulator.transient(step_time=dt@u_ms, end_time=tf@u_s)
if kwargs.get('view',False):
#print(str(circuit))
fig = plt.figure(figsize=(20,4)) # create a figure object
ax = fig.add_subplot(1, 1, 1)
plt.plot(analysis['1']-analysis['2'],label='R')
plt.plot(analysis['2']-analysis['3'],label='L')
ax.plot(analysis['3'],label='C')
#ax.set_ylim(-int(V*1.1)-10,int(V*1.1)+10)
ax.legend()
ax.set_title(f'freq : {w}, voltage: {V}')
ax.set_xlabel('time (ms)')
ax.set_ylabel('current (ma)')
plt.savefig('gallery/RLC_example.png')
print(f'resonance was at {np.sqrt(1/(L*C))}')
return max(abs(analysis['1']-analysis['2']))/R
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)]
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
def test_simple():
circuit = Circuit('pole-zero test circuit')
n = NodeNames('input', 'output')
com = 0
circuit.R('1', n.input, n.output, 1e4)
circuit.C('1', n.input, n.output, 1e-6)
circuit.R('2', n.output, com, 1000)
circuit.C('2', n.output, com, 1e-6)
circuit.L('1', n.output, com, 1e-3)
print("circuit", circuit)
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.polezero(n.input, com, n.output, com, 'vol', 'pz')
print("Poles")
for n in analysis.nodes:
if not n.startswith('pole'): continue
pole = np.array(analysis[n])
print(pole)
print("Zeros")
for n in analysis.nodes:
if not n.startswith('zero'): continue
zero = np.array(analysis[n])
print(zero)
# #cm# relay.m4
period = 50@u_ms
pulse_width = period / 2
circuit = Circuit('Relay')
# circuit.V('digital', 'Vdigital', circuit.gnd, 5@u_V)
circuit.Pulse('clock', 'clock', circuit.gnd, 0@u_V, 5@u_V, pulse_width, period, rise_time=5@u_ms, fall_time=5@u_ms)
circuit.R('base', 'clock', 'base', 100@u_Ω)
circuit.BJT(1, 'collector', 'base', circuit.gnd, 'bjt') # Q is mapped to BJT !
circuit.model('bjt', 'npn', bf=80, cjc=pico(5), rb=100)
circuit.V('analog', 'VccAnalog', circuit.gnd, 8@u_V)
circuit.R('relay', 'VccAnalog', 1, 50@u_Ω)
circuit.L('relay', 1, 'collector', 100@u_mH)
circuit.include(spice_library['1N5822']) # Schottky diode
diode = circuit.X('D', '1N5822', 'collector', 'VccAnalog')
# Fixme: subcircuit node
# diode.minus.add_current_probe(circuit)
####################################################################################################
figure = plt.figure(1, (20, 10))
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.transient(step_time=period/1000, end_time=period*1.1)
axe = plt.subplot(111)
plt.title('')
plt.xlabel('Time [s]')
R1 N001 N002 27.5
L1 N002 N003 0.5
.MODEL Def D
'''
circuit.SinusoidalVoltageSource('1',
'A',
circuit.gnd,
amplitude=220,
frequency=50)
circuit.D('1', circuit.gnd, 'N001', model='Def')
circuit.D('2', 'A', 'N001', model='Def')
circuit.D('3', 'N003', 'A', model='Def')
circuit.D('4', 'N003', circuit.gnd, model='Def')
circuit.R('1', 'N001', 'N002', 27.5)
circuit.L('1', 'N002', 'N003', 0.5)
circuit.model('Def', 'D')
print(circuit)
simulator = circuit.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)
figure1 = plt.figure(1, (20, 10))
plt.plot(analysis.time, current, '-')
# p-channel buck switch
circuit.X('Q', 'DMG4435SSS', 'pch_drain', 'p_gate_drive', 'input')
# resistor from p-channel gate to Vin to bring pchan gate back to Vin when off
circuit.R('pgate', 'input', 'p_gate_drive', 1@u_Ohm)
# nchannel mosfet to pull pchannel gate to ground to turn it on
circuit.X('Q3', 'irf150', 'p_gate_drive', 'nchan_sw_drive', circuit.gnd)
# resistor to drive nch fet, drive comes from controller
circuit.R('pgate_nch', 'nchan_sw_drive', 'gate_drive1_net', 1@u_Ohm)
#####
# Buck LC output and diode
#####
circuit.X('D', '1N5822', circuit.gnd, 'pch_drain')
circuit.L(1, 'pch_drain', 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)
# This clock is used for NGspice mixed signal simulation.
# The python code runs every clock edge, both positive and negative
# clock speed: 20MHz
# clock cycle length: 50ns
circuit.PulseVoltageSource('clk', 'clk', circuit.gnd, 0@u_V, 1@u_V, 0.05@u_us, 0.1@u_us)
#####
# Add a step load
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)
net_2 = Net('N2')
skidl_L1 = L(ref='1', value=5, m=5, temp=5, dtemp=5, ic=5)
skidl_L1['p', 'n'] += net_1, net_2
skidl_L2 = L(ref='2', value=5, m=5, temp=5, dtemp=5, ic=5)
skidl_L2['p', 'n'] += net_1, net_2
skidl_K = K(ind1=skidl_L1, ind2=skidl_L2, coupling=5)
skidl_circ = generate_netlist()
print(skidl_circ)
# In[28]:
pyspice_circ = Circuit('')
#inductors need to exsist to then be coupled
pyspice_circ.L('1', 'N1', 'N2', 5, m=5, temp=5, dtemp=5, ic=5)
pyspice_circ.L('2', 'N1', 'N2', 5, m=5, temp=5, dtemp=5, ic=5)
pyspice_circ.K('1', 'L1', 'L2', coupling_factor=5)
print(pyspice_circ)
# In[29]:
netlist_comp_check(skidl_circ, pyspice_circ)
# ## L | Inductor
#
# PySpice/PySpice/Spice/BasicElement.py; class Inductor(DipoleElement)
#
# skidl/skidl/libs/pyspice_sklib.py; name="L"
#
# ngspice 3.2.9 Inductors:
####################################################################################################
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)
# Parameters
frequency = 1e3
period = 1 / frequency
omega = 2 * np.pi * frequency
I_P1 = 100
L_P1 = 1e-6
L_S1 = 10e-6
K_P1S1 = 0.1
circuit = Circuit('2CoupledInductors')
#Primary Side
circuit.I('I2', circuit.gnd, 'N1', 'AC ' + str(I_P1) + '')
circuit.L('L_P1', circuit.gnd, 'N1', str(L_P1))
# Secondary Side
circuit.L('L_S1', circuit.gnd, 'N2', str(L_S1))
circuit.K('K_P1S1', 'LL_P1', 'LL_S1',
K_P1S1) # NB, it adds an L to the name of the inductor ...
print(circuit)
# # Do the simulation
# simulator = circuit.simulator(temperature=25, nominal_temperature=25)
# analysis = simulator.ac(variation='lin', number_of_points=1, start_frequency=frequency, stop_frequency=frequency)
# # Print the results
# print('--- Results ---')
# for node in analysis.nodes.values():
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
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))
axe = plt.subplot(111)
plot(analysis.out, axis=axe)
plot(analysis['source'], axis=axe)
# plot(analysis['source'] - analysis['out'], axis=axe)
# plot(analysis['gate'], axis=axe)
plt.axhline(y=float(Vout), color='red')
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, )
#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 = 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_Ω)
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
#f# circuit_macros('low-pass-rlc-filter.m4')
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)
#?# pulse 0 5 10 ms
# 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)
#r# We perform an AC analysis.
custom_libraries_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'libraries')
custom_spice_library = SpiceLibrary(custom_libraries_path)
circuit = Circuit('dynamo hub LED driver')
circuit.include(pyspice_examples_spice_library['1N4148']) # standard diode
circuit.include(custom_spice_library['CONSTANT_POWER_LOAD']
) # models a switching regulator
# Hub dynamo model
source = circuit.Sinusoidal('input',
'in',
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,
