####################################################################################################
circuit = Circuit('Ring Modulator')
modulator = circuit.Sinusoidal('modulator',
'in',
circuit.gnd,
amplitude=1,
frequency=kilo(1))
carrier = circuit.Sinusoidal('carrier',
'carrier',
circuit.gnd,
amplitude=10,
frequency=kilo(100))
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,
#!# We will first compute some quiescent points and the corresponding dynamic resistance.
#cm# diode-characteristic-curve-circuit.m4
#!# Since this circuit is equivalent to a voltage divider, we can write the following relation :
#!#
#!# .. math::
#!#
#!# V_{out} = \frac{Z_d}{R_1 + Z_d} V_{in}
#!#
#!# where :math:`Z_d` is the diode impedance.
circuit = Circuit('Diode')
circuit.include(spice_library['BAV21'])
source = circuit.V('input', 'in', circuit.gnd, dc_offset)
circuit.R(1, 'in', 'out', 1 @ u_kΩ)
circuit.D('1', 'out', circuit.gnd, model='BAV21')
quiescent_points = []
for voltage in (dc_offset - ac_amplitude, dc_offset, dc_offset + ac_amplitude):
source.dc_value = voltage
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.operating_point()
# Fixme: handle unit
quiescent_voltage = float(analysis.out)
quiescent_current = -float(analysis.Vinput)
quiescent_points.append(
dict(voltage=voltage,
quiescent_voltage=quiescent_voltage,
quiescent_current=quiescent_current))
print("Quiescent Point {:.1f} mV {:.1f} mA".format(
libraries_path = find_libraries()
spice_library = SpiceLibrary(libraries_path)
####################################################################################################
#r# For this purpose, we use the common high-speed diode 1N4148. The diode is driven by a variable
#r# voltage source through a limiting current resistance.
#f# circuit_macros('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)
#r# We simulate the circuit at these temperatures: 0, 25 and 100 °C.
# Fixme: Xyce ???
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
####################################################################################################
spice_library = SpiceLibrary(libraries_path)
####################################################################################################
figure = plt.figure(1, (20, 10))
####################################################################################################
#r# We define a basic circuit to drive an NPN transistor (2n2222a) using two voltage sources.
#f# circuit_macros('transistor.m4')
circuit = Circuit('Transistor')
Vbase = circuit.V('base', '1', circuit.gnd, 1@u_V)
circuit.R('base', 1, 'base', 1@u_kΩ)
Vcollector = circuit.V('collector', '2', circuit.gnd, 0@u_V)
circuit.R('collector', 2, 'collector', 1@u_kΩ)
# circuit.BJT(1, 'collector', 'base', circuit.gnd, model='generic')
# circuit.model('generic', 'npn')
circuit.include(spice_library['2n2222a'])
circuit.BJT(1, 'collector', 'base', circuit.gnd, model='2n2222a')
#r# We plot the base-emitter diode curve :math:`Ib = f(Vbe)` using a DC sweep simulation.
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.dc(Vbase=slice(0, 3, .01))
axe1 = plt.subplot(221)
axe1.plot(analysis.base, u_mA(-analysis.Vbase)) # Fixme: I_Vbase
axe1.axvline(x=.65, color='red')
import numpy as np
####################################################################################################
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *
####################################################################################################
circuit = Circuit("Millman's theorem")
number_of_branches = 3
for i in range(1, number_of_branches + 1):
circuit.V('input%u' % i, i, circuit.gnd, i @ u_V)
circuit.R(i, i, 'A', i@u_kΩ)
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.operating_point()
node_A = analysis.A
print('Node {}: {:5.2f} V'.format(str(node_A), float(node_A)))
# o#
branch_voltages = np.arange(1, number_of_branches +1)
branch_resistances = branch_voltages * float(kilo(1))
conductances = 1 / branch_resistances
voltage_A = np.sum(branch_voltages * conductances) / np.sum(conductances)
print('V(A) = {:5.2f} V'.format(voltage_A))
#o#
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,
end_time=source.period * 20,
ESR_in = 120@u_mOhm
Cin = 10@u_uF
# parameters on input to buck
circuit.V('input', 'input', circuit.gnd, Vin)
circuit.C('input', 'input', circuit.gnd, Cin)
#####
# Buck switch
#####
# 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)
from Transformer import Transformer
####################################################################################################
circuit = Circuit('Transformer')
ac_line = circuit.AcLine('input',
'input',
circuit.gnd,
rms_voltage=230,
frequency=50)
circuit.subcircuit(Transformer(turn_ratio=10))
circuit.X('transformer', 'Transformer', 'input', circuit.gnd, 'output',
circuit.gnd)
circuit.R('load', 'output', circuit.gnd, kilo(1))
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.transient(step_time=ac_line.period / 200,
end_time=ac_line.period * 3)
figure = plt.figure(1, (20, 10))
plot(analysis.input)
plot(analysis.output)
plt.legend(('Vin [V]', 'Vout [V]'), loc=(.8, .8))
plt.grid()
plt.xlabel('t [s]')
plt.ylabel('[V]')
plt.tight_layout()
plt.show()
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]')
axe.grid()
# Fixme: axis vs axe ...
# 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
# Call the MyNgSpiceShared
from PySpice.Doc.ExampleTools import find_libraries
from PySpice.Spice.Library import SpiceLibrary
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *
####################################################################################################
libraries_path = find_libraries()
spice_library = SpiceLibrary(libraries_path)
####################################################################################################
circuit = Circuit('test')
R1 = circuit.R(1, 'p1', 'p2', 4 @ u_kΩ)
R2 = circuit.R(2, 'p2', 'p6', 1 @ u_kΩ)
R3 = circuit.R(3, 'p1', 'p5', 1 @ u_kΩ)
R4 = circuit.R(4, 'p5', 'p6', 1 @ u_kΩ)
R5 = circuit.R(5, 'p6', 0, 1e-9 @ u_Ω)
I1 = circuit.I(1, 0, 'p1', 1 @ u_A)
V1 = circuit.V(1, 'p1', 'p4', -10 @ u_V)
V2 = circuit.V(2, 'p2', 'p3', -10 @ u_V)
print(str(circuit))
simulator = circuit.simulator(simulator='xyce-serial')
analysis = simulator.operating_point()
#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)
analysis = simulator.transient(step_time=ac_line.period / 200,
#r# This example shows how to pass raw spice definitions to a netlist.
####################################################################################################
import PySpice.Logging.Logging as Logging
logger = Logging.setup_logging()
####################################################################################################
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *
####################################################################################################
#r# Let define a circuit.
circuit = Circuit('Test')
#r# Pass raw Spice definitions to a circuit, aka netlist, content is inserted at the beginning of
#r# the netlist.
circuit.raw_spice = '''
Vinput in 0 10V
R1 in out 9kOhm
'''
#r# Pass element parameters as raw Spice, content is concatenated with `R2 out 0`
circuit.R(2, 'out', 0, raw_spice='1k')
print(circuit)
#o#
#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)
plot(analysis.Vinput)
plot(analysis.output - analysis.scope_ground)
plt.legend(('Vin [V]', 'I [A]'), loc=(.8,.8))
plt.grid()
plt.xlabel('t [s]')
plt.ylabel('[V]')
####################################################################################################
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()
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, ax = plt.subplots(figsize=(20, 10))
# .ac dec 5 10m 1G
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
import PySpice.Logging.Logging as Logging
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,
##############################################
def get_isrc_data(self, current, time, node, ngspice_id):
self._logger.debug('ngspice_id-{} get_isrc_data @{} node {}'.format(
ngspice_id, time, node))
current[0] = 1.
return 0
####################################################################################################
circuit = Circuit('Voltage Divider')
circuit.V('input', 'input', circuit.gnd, 'dc 0 external')
circuit.R(1, 'input', 'output', kilo(10))
circuit.R(2, 'output', circuit.gnd, kilo(1))
amplitude = 10
frequency = Frequency(50)
ngspice_shared = MyNgSpiceShared(amplitude=amplitude,
frequency=frequency,
send_data=False)
simulator = circuit.simulator(temperature=25,
nominal_temperature=25,
simulator='shared',
ngspice_shared=ngspice_shared)
period = float(frequency.period)
analysis = simulator.transient(step_time=period / 200, end_time=period * 2)
####################################################################################################
####################################################################################################
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))
# PySpice example code
import PySpice.Logging.Logging as Logging
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *
logger = Logging.setup_logging()
circuit = Circuit('Current Divider')
circuit.I('input', 1, circuit.gnd, 1 @ u_A) # Fixme: current value
circuit.R(1, 1, circuit.gnd, 2 @ u_kΩ)
circuit.R(2, 1, circuit.gnd, 1 @ u_kΩ)
for resistance in (circuit.R1, circuit.R2):
resistance.minus.add_current_probe(circuit) # to get positive value
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.operating_point()
# Fixme: current over resistor
for node in analysis.branches.values():
print('Node {}: {:5.2f} A'.format(
str(node), float(node))) # Fixme: format value + unit
from PySpice.Plot.BodeDiagram import bode_diagram
from PySpice.Probe.Plot import plot
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *
from OperationalAmplifier import BasicOperationalAmplifier
####################################################################################################
circuit = Circuit('Operational Amplifier')
# AC 1 PWL(0US 0V 0.01US 1V)
circuit.Sinusoidal('input', 'in', circuit.gnd, amplitude=1 @ u_V)
circuit.subcircuit(BasicOperationalAmplifier())
circuit.X('op', 'BasicOperationalAmplifier', 'in', circuit.gnd, 'out')
circuit.R('load', 'out', circuit.gnd, 470 @ u_Ω)
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')
figure = plt.figure(1, (20, 10))
plt.title("Bode Diagram of an Operational Amplifier")
bode_diagram(
axes=(plt.subplot(211), plt.subplot(212)),
frequency=analysis.frequency,
gain=20 * np.log10(np.absolute(analysis.out)),
phase=np.angle(analysis.out, deg=False),
marker='.',
Rcex2 = d.add(elm.Resistor().up().label('Rc,ex', loc='bottom'))
d.add(elm.Dot().label('condensor').color('red'))
d.add(elm.Resistor().endpoints(Rcex.start, Rcex2.start).label('Ra,w'))
d.add(elm.Resistor().endpoints(Rcw.start,
Rcw2.start).label('Ra,wk').color('orange'))
d.draw()
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *
circuit = Circuit('HeatPipe')
circuit.V('input', 1, circuit.gnd, 80 @ u_V)
circuit.R('Reex', 1, 2, 0.0000001 @ u_kΩ)
circuit.R('Rew', 2, 3, 0.2545383947014702 @ u_kΩ)
circuit.R('Rewk', 3, 4, 0.7943030881649811 @ u_kΩ)
circuit.R('Rintere', 4, 5, 0.00034794562965549745 @ u_kΩ)
circuit.R('Raw', 2, 9, 456.90414284754644 @ u_kΩ)
circuit.R('Rawk', 3, 8, 744.3007160198263 @ u_kΩ)
circuit.R('Rv', 5, 6, 8.852701208752846e-06 @ u_kΩ)
circuit.R('Rinterc', 6, 7, 0.00017397281482774872 @ u_kΩ)
circuit.R('Rcwk', 7, 8, 0.39715154408249054 @ u_kΩ)
circuit.R('Rcw', 8, 9, 0.1272691973507351 @ u_kΩ)
circuit.R('Rcex', 9, circuit.gnd, 0.0000001 @ u_kΩ)
for resistance in (circuit.RReex, circuit.RRcex):
resistance.minus.add_current_probe(circuit) # to get positive value
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
period = 50 @ u_ms
pulse_width = period / 2
circuit = Circuit('Relay')
# circuit.V('digital', 'Vdigital', circuit.gnd, 5@u_V)
circuit.PulseVoltageSource('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,
model='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, ax = plt.subplots(figsize=(20, 10))
from PySpice.Spice.Netlist import Circuit
from PySpice.Unit import *
# define a circuit
circuit = Circuit('Voltage Divider')
# setup voltage sources and resistors
# (note to self, in vim use cntl+k W* to write Ω symbol)
circuit.V('dc', 'input', circuit.gnd, 1@u_V)
circuit.R('r_top', 'input', 'output', 1@u_kΩ)
circuit.R('r_bottom', 'output', circuit.gnd, 1@u_kΩ)
# set simulator settings
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.dc(Vdc = slice(3,12,1))
# print analysis of voltages of each node
for node in (analysis['output']):
print("voltage at output" + " " + str(float(node)))
####################################################################################################
#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))
self._logger.debug('ngspice_id-{} get_vsrc_data @{} node {}'.format(
ngspice_id, time, node))
voltage[0] = self._amplitude * math.sin(self._pulsation * time)
return 0
def get_isrc_data(self, current, time, node, ngspice_id):
self._logger.debug('ngspice_id-{} get_isrc_data @{} node {}'.format(
ngspice_id, time, node))
current[0] = 1.
return 0
circuit = Circuit('Voltage Divider')
circuit.V('input', 'input', circuit.gnd, 'dc 0 external')
circuit.R(1, 'input', 'output', 10 @ u_kΩ)
circuit.R(2, 'output', circuit.gnd, 1 @ u_kΩ)
amplitude = 10 @ u_V
frequency = 50 @ u_Hz
ngspice_shared = MyNgSpiceShared(amplitude=amplitude,
frequency=frequency,
send_data=False)
simulator = circuit.simulator(temperature=25,
nominal_temperature=25,
simulator='ngspice-shared',
ngspice_shared=ngspice_shared)
period = float(frequency.period)
analysis = simulator.transient(step_time=period / 200, end_time=period * 2)
figure1 = plt.figure(1, (20, 10))
import PySpice.Logging.Logging as Logging
logger = Logging.setup_logging()
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)
####################################################################################################
circuit = Circuit('Ring Modulator')
modulator = circuit.SinusoidalVoltageSource('modulator',
'in',
circuit.gnd,
amplitude=1 @ u_V,
frequency=1 @ u_kHz)
carrier = circuit.SinusoidalVoltageSource('carrier',
'carrier',
circuit.gnd,
amplitude=10 @ u_V,
frequency=100 @ u_kHz)
circuit.R('in', 'in', 1, 50 @ u_Ω)
circuit.R('carrier', 'carrier', 2, 50 @ u_Ω)
circuit.include(spice_library['1N4148'])
circuit.subcircuit(
RingModulator(
outer_inductance=1 @ u_uH,
inner_inductance=1 @ u_uH,
coupling=.99,
diode_model='1N4148',
))
circuit.X(
'ring_modulator',
'RingModulator',
1,
circuit.gnd,
####################################################################################################
#r# We will drive the transmission line with a pulse source and use a standard 50 Ω load.
circuit = Circuit('Transmission Line')
circuit.PulseVoltageSource('pulse', 'input', circuit.gnd, 0 @ u_V, 1 @ u_V,
1 @ u_ns, 1 @ u_us)
circuit.LosslessTransmissionLine('delay',
'output',
circuit.gnd,
'input',
circuit.gnd,
impedance=50,
time_delay=40e-9)
circuit.R('load', 'output', circuit.gnd, 50 @ u_Ω)
simulator = circuit.simulator(temperature=25, nominal_temperature=25)
analysis = simulator.transient(step_time=1e-11, end_time=100e-9)
####################################################################################################
figure = plt.figure(None, (20, 6))
plot(analysis['input'])
plot(analysis['output'])
plt.xlabel('Time [s]')
plt.ylabel('Voltage (V)')
plt.grid()
plt.legend(['input', 'output'], loc='upper right')
plt.show()
ele_end = [draw_scale * i for i in ele[3]]
if ele[1][0] == 'R':
ele_label_top = 'R' + str(ele[0])
ele_label_bot = str(ele[4]) + 'K$\Omega$'
d.add(e.RES,
label=ele_label_top,
botlabel=ele_label_bot,
xy=ele_start,
to=ele_end)
if ele[2] not in node_dict:
node_ctr = node_ctr + 1
node_dict.update({ele[2]: node_ctr})
if ele[3] not in node_dict:
node_ctr = node_ctr + 1
node_dict.update({ele[3]: node_ctr})
circuit.R(ctr, node_dict[ele[2]], node_dict[ele[3]], ele[4] @ u_kΩ)
ctr = ctr + 1
elif ele[1] == 'W':
# e.LINE represents wires
d.add(e.LINE, xy=ele_start, to=ele_end)
if ele[2] not in node_dict:
node_ctr = node_ctr + 1
node_dict.update({ele[2]: node_ctr})
if ele[3] not in node_dict:
node_ctr = node_ctr + 1
node_dict.update({ele[3]: node_ctr})
circuit.R(ctr, node_dict[ele[2]], node_dict[ele[3]], 0 @ u_kΩ)
ctr = ctr + 1
elif ele[1] == 'V':
ele_label_top = 'V' + str(ele[0])
ele_label_bot = str(ele[4]) + 'V'
