Computer simulation of electric circuits
Computers can be powerful tools if used properly, especially in
the realms of science and engineering. Software exists for the
simulation of electric circuits by computer, and these programs can
be very useful in helping circuit designers test ideas before
actually building real circuits, saving much time and money.
These same programs can be fantastic aids to the beginning
student of electronics, allowing the exploration of ideas quickly
and easily with no assembly of real circuits required. Of course,
there is no substitute for actually building and testing real
circuits, but computer simulations certainly assist in the learning
process by allowing the student to experiment with changes and see
the effects they have on circuits. Throughout this book, I'll be
incorporating computer printouts from circuit simulation frequently
in order to illustrate important concepts. By observing the results
of a computer simulation, a student can gain an intuitive grasp of
circuit behavior without the intimidation of abstract mathematical
analysis.
To simulate circuits on computer, I make use of a particular
program called SPICE, which works by describing a circuit to the
computer by means of a listing of text. In essence, this listing is
a kind of computer program in itself, and must adhere to the
syntactical rules of the SPICE language. The computer is then used
to process, or "run," the SPICE program, which interprets the text
listing describing the circuit and outputs the results of its
detailed mathematical analysis, also in text form. Many details of
using SPICE are described in volume 5 ("Reference") of this book
series for those wanting more information. Here, I'll just introduce
the basic concepts and then apply SPICE to the analysis of these
simple circuits we've been reading about.
First, we need to have SPICE installed on our computer. As a free
program, it is commonly available on the internet for download, and
in formats appropriate for many different operating systems. In this
book, I use one of the earlier versions of SPICE: version 2G6, for
its simplicity of use.
Next, we need a circuit for SPICE to analyze. Let's try one of
the circuits illustrated earlier in the chapter. Here is its
schematic diagram:
This simple circuit consists of a battery and a resistor
connected directly together. We know the voltage of the battery (10
volts) and the resistance of the resistor (5 Ω), but nothing else
about the circuit. If we describe this circuit to SPICE, it should
be able to tell us (at the very least), how much current we have in
the circuit by using Ohm's Law (I=E/R).
SPICE cannot directly understand a schematic diagram or any other
form of graphical description. SPICE is a text-based computer
program, and demands that a circuit be described in terms of its
constituent components and connection points. Each unique connection
point in a circuit is described for SPICE by a "node" number. Points
that are electrically common to each other in the circuit to be
simulated are designated as such by sharing the same number. It
might be helpful to think of these numbers as "wire" numbers rather
than "node" numbers, following the definition given in the previous
section. This is how the computer knows what's connected to what: by
the sharing of common wire, or node, numbers. In our example
circuit, we only have two "nodes," the top wire and the bottom wire.
SPICE demands there be a node 0 somewhere in the circuit, so we'll
label our wires 0 and 1:
In the above illustration, I've shown multiple "1" and "0" labels
around each respective wire to emphasize the concept of common
points sharing common node numbers, but still this is a graphic
image, not a text description. SPICE needs to have the component
values and node numbers given to it in text form before any analysis
may proceed.
Creating a text file in a computer involves the use of a program
called a text editor. Similar to a word processor, a text
editor allows you to type text and record what you've typed in the
form of a file stored on the computer's hard disk. Text editors lack
the formatting ability of word processors (no italic, bold,
or underlined characters), and this is a good thing, since
programs such as SPICE wouldn't know what to do with this extra
information. If we want to create a plain-text file, with absolutely
nothing recorded except the keyboard characters we select, a text
editor is the tool to use.
If using a Microsoft operating system such as DOS or Windows, a
couple of text editors are readily available with the system. In
DOS, there is the old Edit text editing program, which may be
invoked by typing edit at the command prompt. In Windows
(3.x/95/98/NT/Me/2k/XP), the Notepad text editor is your
stock choice. Many other text editing programs are available, and
some are even free. I happen to use a free text editor called Vim,
and run it under both Windows 95 and Linux operating systems. It
matters little which editor you use, so don't worry if the
screenshots in this section don't look like yours; the important
information here is what you type, not which editor
you happen to use.
To describe this simple, two-component circuit to SPICE, I will
begin by invoking my text editor program and typing in a "title"
line for the circuit:
We can describe the battery to the computer by typing in a line
of text starting with the letter "v" (for "Voltage
source"), identifying which wire each terminal of the battery
connects to (the node numbers), and the battery's voltage, like
this:
This line of text tells SPICE that we have a voltage source
connected between nodes 1 and 0, direct current (DC), 10 volts.
That's all the computer needs to know regarding the battery. Now we
turn to the resistor: SPICE requires that resistors be described
with a letter "r," the numbers of the two nodes (connection points),
and the resistance in ohms. Since this is a computer simulation,
there is no need to specify a power rating for the resistor. That's
one nice thing about "virtual" components: they can't be harmed by
excessive voltages or currents!
Now, SPICE will know there is a resistor connected between nodes
1 and 0 with a value of 5 Ω. This very brief line of text tells the
computer we have a resistor ("r") connected between the
same two nodes as the battery (1 and 0), with a resistance value of
5 Ω.
If we add an
.end statement to this collection of SPICE
commands to indicate the end of the circuit description, we will
have all the information SPICE needs, collected in one file and
ready for processing. This circuit description, comprised of lines
of text in a computer file, is technically known as a netlist,
or deck:
Once we have finished typing all the necessary SPICE commands, we
need to "save" them to a file on the computer's hard disk so that
SPICE has something to reference to when invoked. Since this is my
first SPICE netlist, I'll save it under the filename "circuit1.cir"
(the actual name being arbitrary). You may elect to name your first
SPICE netlist something completely different, just as long as you
don't violate any filename rules for your operating system, such as
using no more than 8+3 characters (eight characters in the name, and
three characters in the extension: 12345678.123) in DOS.
To invoke SPICE (tell it to process the contents of the
circuit1.cir netlist file), we have to exit from the text
editor and access a command prompt (the "DOS prompt" for Microsoft
users) where we can enter text commands for the computer's operating
system to obey. This "primitive" way of invoking a program may seem
archaic to computer users accustomed to a "point-and-click"
graphical environment, but it is a very powerful and flexible way of
doing things. Remember, what you're doing here by using SPICE is a
simple form of computer programming, and the more comfortable you
become in giving the computer text-form commands to follow -- as
opposed to simply clicking on icon images using a mouse -- the more
mastery you will have over your computer.
Once at a command prompt, type in this command, followed by an
[Enter] keystroke (this example uses the filename
circuit1.cir;
if you have chosen a different filename for your netlist file,
substitute it):
spice < circuit1.cir
Here is how this looks on my computer (running the Linux
operating system), just before I press the [Enter] key:
As soon as you press the [Enter] key to issue this command, text
from SPICE's output should scroll by on the computer screen. Here is
a screenshot showing what SPICE outputs on my computer (I've
lengthened the "terminal" window to show you the full text. With a
normal-size terminal, the text easily exceeds one page length):
SPICE begins with a reiteration of the netlist, complete with
title line and .end statement. About halfway through the
simulation it displays the voltage at all nodes with reference to
node 0. In this example, we only have one node other than node 0, so
it displays the voltage there: 10.0000 volts. Then it displays the
current through each voltage source. Since we only have one voltage
source in the entire circuit, it only displays the current through
that one. In this case, the source current is 2 amps. Due to a quirk
in the way SPICE analyzes current, the value of 2 amps is output as
a negative (-) 2 amps.
The last line of text in the computer's analysis report is "total
power dissipation," which in this case is given as "2.00E+01" watts:
2.00 x 101, or 20 watts. SPICE outputs most figures in
scientific notation rather than normal (fixed-point) notation. While
this may seem to be more confusing at first, it is actually less
confusing when very large or very small numbers are involved. The
details of scientific notation will be covered in the next chapter
of this book.
One of the benefits of using a "primitive" text-based program
such as SPICE is that the text files dealt with are extremely small
compared to other file formats, especially graphical formats used in
other circuit simulation software. Also, the fact that SPICE's
output is plain text means you can direct SPICE's output to another
text file where it may be further manipulated. To do this, we
re-issue a command to the computer's operating system to invoke
SPICE, this time redirecting the output to a file I'll call "output.txt":
SPICE will run "silently" this time, without the stream of text
output to the computer screen as before. A new file,
output1.txt,
will be created, which you may open and change using a text editor
or word processor. For this illustration, I'll use the same text
editor (Vim) to open this file:
Now, I may freely edit this file, deleting any extraneous text
(such as the "banners" showing date and time), leaving only the text
that I feel to be pertinent to my circuit's analysis:
Once suitably edited and re-saved under the same filename (output.txt
in this example), the text may be pasted into any kind of document,
"plain text" being a universal file format for almost all computer
systems. I can even include it directly in the text of this book --
rather than as a "screenshot" graphic image -- like this:
my first circuit
v 1 0 dc 10
r 1 0 5
.end
node voltage
( 1) 10.0000
voltage source currents
name current
v -2.000E+00
total power dissipation 2.00E+01 watts
Incidentally, this is the preferred format for text output from
SPICE simulations in this book series: as real text, not as graphic
screenshot images.
To alter a component value in the simulation, we need to open up
the netlist file (circuit1.cir) and make the required
modifications in the text description of the circuit, then save
those changes to the same filename, and re-invoke SPICE at the
command prompt. This process of editing and processing a text file
is one familiar to every computer programmer. One of the reasons I
like to teach SPICE is that it prepares the learner to think and
work like a computer programmer, which is good because computer
programming is a significant area of advanced electronics work.
Earlier we explored the consequences of changing one of the three
variables in an electric circuit (voltage, current, or resistance)
using Ohm's Law to mathematically predict what would happen. Now
let's try the same thing using SPICE to do the math for us.
If we were to triple the voltage in our last example circuit from
10 to 30 volts and keep the circuit resistance unchanged, we would
expect the current to triple as well. Let's try this, re-naming our
netlist file so as to not over-write the first file. This way, we
will have both versions of the circuit simulation stored on
the hard drive of our computer for future use. The following text
listing is the output of SPICE for this modified netlist, formatted
as plain text rather than as a graphic image of my computer screen:
second example circuit
v 1 0 dc 30
r 1 0 5
.end
node voltage
( 1) 30.0000
voltage source currents
name current
v -6.000E+00
total power dissipation 1.80E+02 watts
Just as we expected, the current tripled with the voltage
increase. Current used to be 2 amps, but now it has increased to 6
amps (-6.000 x 100). Note also how the total power
dissipation in the circuit has increased. It was 20 watts before,
but now is 180 watts (1.8 x 102). Recalling that power is
related to the square of the voltage (Joule's Law: P=E2/R),
this makes sense. If we triple the circuit voltage, the power should
increase by a factor of nine (32 = 9). Nine times 20 is
indeed 180, so SPICE's output does indeed correlate with what we
know about power in electric circuits.
If we want to see how this simple circuit would respond over a
wide range of battery voltages, we can invoke some of the more
advanced options within SPICE. Here, I'll use the ".dc"
analysis option to vary the battery voltage from 0 to 100 volts in 5
volt increments, printing out the circuit voltage and current at
every step. The lines in the SPICE netlist beginning with a star
symbol ("*") are comments. That is, they don't tell
the computer to do anything relating to circuit analysis, but merely
serve as notes for any human being reading the netlist text.
third example circuit
v 1 0
r 1 0 5
*the ".dc" statement tells spice to sweep the "v" supply
*voltage from 0 to 100 volts in 5 volt steps.
.dc v 0 100 5
.print dc v(1) i(v)
.end
The
.print command in this SPICE netlist instructs SPICE
to print columns of numbers corresponding to each step in the
analysis:
v i(v)
0.000E+00 0.000E+00
5.000E+00 -1.000E+00
1.000E+01 -2.000E+00
1.500E+01 -3.000E+00
2.000E+01 -4.000E+00
2.500E+01 -5.000E+00
3.000E+01 -6.000E+00
3.500E+01 -7.000E+00
4.000E+01 -8.000E+00
4.500E+01 -9.000E+00
5.000E+01 -1.000E+01
5.500E+01 -1.100E+01
6.000E+01 -1.200E+01
6.500E+01 -1.300E+01
7.000E+01 -1.400E+01
7.500E+01 -1.500E+01
8.000E+01 -1.600E+01
8.500E+01 -1.700E+01
9.000E+01 -1.800E+01
9.500E+01 -1.900E+01
1.000E+02 -2.000E+01
If I re-edit the netlist file, changing the
.print
command into a .plot command, SPICE will output a crude
graph made up of text characters:
Legend: + = v#branch
------------------------------------------------------------------------
sweep v#branch-2.00e+01 -1.00e+01 0.00e+00
---------------------|------------------------|------------------------|
0.000e+00 0.000e+00 . . +
5.000e+00 -1.000e+00 . . + .
1.000e+01 -2.000e+00 . . + .
1.500e+01 -3.000e+00 . . + .
2.000e+01 -4.000e+00 . . + .
2.500e+01 -5.000e+00 . . + .
3.000e+01 -6.000e+00 . . + .
3.500e+01 -7.000e+00 . . + .
4.000e+01 -8.000e+00 . . + .
4.500e+01 -9.000e+00 . . + .
5.000e+01 -1.000e+01 . + .
5.500e+01 -1.100e+01 . + . .
6.000e+01 -1.200e+01 . + . .
6.500e+01 -1.300e+01 . + . .
7.000e+01 -1.400e+01 . + . .
7.500e+01 -1.500e+01 . + . .
8.000e+01 -1.600e+01 . + . .
8.500e+01 -1.700e+01 . + . .
9.000e+01 -1.800e+01 . + . .
9.500e+01 -1.900e+01 . + . .
1.000e+02 -2.000e+01 + . .
---------------------|------------------------|------------------------|
sweep v#branch-2.00e+01 -1.00e+01 0.00e+00
In both output formats, the left-hand column of numbers
represents the battery voltage at each interval, as it increases
from 0 volts to 100 volts, 5 volts at a time. The numbers in the
right-hand column indicate the circuit current for each of those
voltages. Look closely at those numbers and you'll see the
proportional relationship between each pair: Ohm's Law (I=E/R) holds
true in each and every case, each current value being 1/5 the
respective voltage value, because the circuit resistance is exactly
5 Ω. Again, the negative numbers for current in this SPICE analysis
is more of a quirk than anything else. Just pay attention to the
absolute value of each number unless otherwise specified.
There are even some computer programs able to interpret and
convert the non-graphical data output by SPICE into a graphical
plot. One of these programs is called Nutmeg, and its output
looks something like this:
Note how Nutmeg plots the resistor voltage
v(1) (voltage
between node 1 and the implied reference point of node 0) as a line
with a positive slope (from lower-left to upper-right).
Whether or not you ever become proficient at using SPICE is not
relevant to its application in this book. All that matters is that
you develop an understanding for what the numbers mean in a
SPICE-generated report. In the examples to come, I'll do my best to
annotate the numerical results of SPICE to eliminate any confusion,
and unlock the power of this amazing tool to help you understand the
behavior of electric circuits.
Lessons In Electric Circuits copyright (C) 2000-2002 Tony
R. Kuphaldt, under the terms and conditions of the
Design
Science License.
|
