Performing A Circuit Simulation In KiCad

Last Updated: March 21, 2023
Originally Published: July 1, 2019

Skill Level: Intermediate

Table Of Contents

• Introduction
• What Is Needed
• Background Information
• Setting Up The Schematic
• Running The Simulation
• Viewing The Waveforms
• Summary

Introduction

This tutorial will teach you how to run a circuit simulation in KiCad. A basic understanding of electronics is expected along with knowing how to create schematic diagrams in KiCad.

The focus of this article will be on running circuit simulations within KiCad, not on how to create a schematic. There are already quite a few tutorials and resources on the internet to help you with creating schematics, including the KiCad Eeschema manual. I will instead concentrate on how to set up and run simulations in KiCad because that material is not as readily available.

The resources created for this tutorial are available on GitHub for your reference.

This tutorial is provided as a free service to our valued readers. Please help us continue this endeavor by considering a donation.

What Is Needed

• Linux, macOS, Or Windows Based Computer
• KiCad

Background Information

Sometimes a BJT transistor is used as a switch to drive higher loads (current) than is typically capable from a microcontroller’s GPIO output pins. For instance, the maximum current ratings of the GPIO pins for the Arduino Uno is 20 mA and the Raspberry Pi is 16 mA. A typical setup is shown below.

This involves operating the transistor in saturation mode, i.e., V_E < V_B > V_C for NPN and V_E > V_B < V_C for PNP transistors. When a typical BJT transistor is operating as a switch in this mode, certain assumptions are usually made to make the calculations easier.

• V_CE ≈ 0 V
• β ≈ 10

This means we can effectively ignore the transistor in our load current calculations and the GPIO pin current (I_B) is about a tenth of the load current (I_C). As a simple example, let’s say the load is just a 150 Ω resistor with a 5 V supply. The assumptions imply the load current will be about 33.3 mA (5 / 150) and the GPIO pin current will be about 3.33 mA (33.3 / 10). I set out to verify these assumptions by performing a circuit simulation in KiCad.

My development system consists of KiCad 7 running on macOS. If you are using a different computer setup, the vast majority of this tutorial should still apply, however, some minor changes may be necessary.

Setting Up The Schematic

Create a schematic named TransistorSwitchSimulation in the KiCad Eeschema schematic layout editor to match the one shown above. Vcc and Vin are global input labels and Vb, Vc, and Ve are net labels.

KiCad uses ngspice internally to perform SPICE based circuit simulations. Therefore, in order to run a simulation, we need to add the appropriate SPICE related information to the schematic so that ngspice knows what to do.

To begin, we need to add power sources that SPICE understands. The typical power supplies used when creating schematics will not be understood by the SPICE engine. Place a new VDC voltage source component (located within the Simulation_SPICE component library) into the schematic. Wire a global output label named Vcc to the positive side and a GND power port to the negative side of the VDC component. Change the value of VDC to 5, meaning it will provide a 5 V DC supply.

Place an additional VDC voltage source in the same fashion, but this time use a label of Vin with a value of 0. This corresponds to a GPIO output pin being in an “off” state. The global labels provide the connections of the voltage sources to the rest of the circuit. My Vcc and Vin sources were referenced as V1 and V2 respectively.

SPICE uses models to describe the behavior of electronic components. KiCad implicitly assigns models to passive components, such as resistors and capacitors, however, models for semiconductor devices, such as diodes and transistors, need to be explicitly assigned.

We need to associate a SPICE model with the PN2222A transistor used in our schematic. SPICE models for particular components can usually be found from manufacturers or suppliers. I am using the following 2N2222 model for the transistor that I obtained from the LTspice standard BJT library. The PN2222A transistor is a less expensive version of the original 2N2222, but is considered equivalent except for pinouts and when operated under extreme conditions.

* Modified from LTspice BJT standard library (2N2222)
.model PN2222A NPN (IS=1E-14 VAF=100
+ BF=200 IKF=0.3 XTB=1.5 BR=3
+ CJC=8E-12 CJE=25E-12 TR=100E-9 TF=400E-12
+ ITF=1 VTF=2 XTF=3 RB=10 RC=.3 RE=.2)

Create a file named PN2222A.lib with the contents of the above model and place it inside the KiCad TransistorSwitchSimulation project directory.

Now that the model is created, we need to attach it to the transistor. Right-click on the transistor and select Properties… from the contextual menu. Click the Simulation Model… button to open the Simulation Model Editor and then open the Model tab. Select the SPICE model from file option, choose the PN2222A.lib file, and then select PN2222A as the Model. The entries should look like those in the window shown below.

KiCad uses different pin assignments for semiconductor components than is expected by the ngspice engine. For example, the standard SPICE pin assignments for a BJT transistor are pin 1 = collector, pin 2 = base, and pin 3 = emitter, whereas KiCad uses 1 = E, 2 = B, and 3 = C. This can cause great confusion for users wondering what the heck is going on. To fix this issue, click on the Pin Assignments tab and swap the collector and emitter pin assignments as shown below. Click OK when you’re done and also close the Symbol Properties window as well by clicking OK again.

Now we need to tell SPICE (ngspice) what we want to simulate. The best way to provide SPICE control statements is simply to add them via placing text directly in the schematic itself. There is another way we can do this that is much more user friendly, as I will show you later, but those statements are not retained between separate simulations and will need to be reentered each time. Placing them directly in the schematic not only allows you to retain the SPICE statements, but also gives you the benefit of seeing your statements up front when you open the schematic in the future.

Let’s run a transient analysis simulating the circuit from 0 to 1 ms using 1 us for each step. This corresponds to the SPICE control statement shown below.

.tran 1u 1m

Add the above text somewhere in your schematic. If you are not familiar with placing text in a schematic, this can be accomplished by selecting Place > Add Text from the main menu, adding the text in the popup window, clicking the OK button, and then clicking where you want the text to be placed.

Your completed schematic should now look like that shown below.

Save your schematic when you are done.

Running The Simulation

Select Inspect > Simulator… from the main menu and you will see the Spice Simulator window appear.

Let’s take a look at the simulation settings. Click the Sim Command icon (gear) within the toolbar to see the Simulation Command window. The Transient tab should already be selected and populated with the control statement data it obtained from the text within the schematic. Here you can see the correlation of 1u to Time step and 1m to Final time. This is the place I mentioned earlier where you can enter your SPICE control statements in a more user friendly way, but your entries will not be saved between simulations. The other tabs provide for different simulation control statements. If you click the Custom tab, you will see the exact control statement retrieved from the schematic. We also need to make sure the Compatibility mode is set to PSpice and LTSpice if it is not already. Click the OK button when done.

The big moment arrives. Click the blue arrow button (Run/Stop Simulation) in the toolbar to run the simulation. A blank Plot1 – TRAN waveform viewer will appear at the top and the simulation output will be shown at the bottom with the following contents.

Note: Compatibility modes selected: ps lt a
Circuit: KiCad schematic
Doing analysis at TEMP = 27.000000 and TNOM = 27.000000
Initial Transient Solution
--------------------------
Node                                   Voltage
----                                   -------
vin                                          0
probe_int_/vb_r1                   5.00333e-09
/vb                                5.00333e-09
vcc                                          5
probe_int_/vc_r2                             5
/vc                                          5
probe_int_/vc_q1_1                           5
probe_int_/vb_q1_2                 5.00333e-09
probe_int_gnd_q1_3                           0
q1:e#branch                          -1.05e-14
q1:b#branch                       -5.00333e-12
q1:c#branch                        1.00129e-11
v2#branch                          5.00333e-12
v1#branch                         -1.00129e-11
r2#branch                          1.00129e-11
r1#branch                         -5.00333e-12
 Reference value :  0.00000e+00

No. of Data Rows : 1008

We can see from the output that Vcc and Vin have the expected values of 5 and 0 respectively. We can also see that the collector voltage (Vc) is the same as Vcc, meaning no, or negligible, current is flowing through the R2 resistor. This is expected since the transistor is in its “off” (cutoff mode) state.

Now that a simulation has run, the SPICE netlist used for the simulation can be viewed by selecting Simulation > Show SPICE Netlist… from the main menu.

Now let’s turn the transistor on. Close the Spice Simulator window and click the Save button. Change the value of the Vin voltage source to 5, representing the GPIO output pin being in an “on” state. Save your schematic. Run a new simulation. The output this time should look like the following.

Note: Compatibility modes selected: ps lt a
Circuit: KiCad schematic
Doing analysis at TEMP = 27.000000 and TNOM = 27.000000
Initial Transient Solution
--------------------------
Node                                   Voltage
----                                   -------
vin                                          5
probe_int_/vb_r1                      0.807997
/vb                                   0.807997
vcc                                          5
probe_int_/vc_r2                     0.0571069
/vc                                  0.0571069
probe_int_/vc_q1_1                   0.0571069
probe_int_/vb_q1_2                    0.807997
probe_int_gnd_q1_3                           0
q1:e#branch                         -0.0371446
q1:b#branch                           0.004192
q1:c#branch                          0.0329526
v2#branch                            -0.004192
v1#branch                           -0.0329526
r2#branch                            0.0329526
r1#branch                             0.004192
 Reference value :  0.00000e+00

No. of Data Rows : 1008

We can see from this output with Vin equal to 5 V that Vc is now 57.1 mV. This means the transistor is now “on” and current is flowing through the 150 Ω (R2) resistor. The v1#branch and v2#branch entries represent the steady state current flowing into the voltage sources. That is why they are negative values. Similarly, the r1#branch and r2#branch represent the current flowing through resistor R1 (into the base of the transistor) and through resistor R2 (into the collector of the transistor) respectively.

If you see a negative current through a resistor, you can change either the orientation of the resistor by 180 degrees in the schematic or swap the pins as we did earlier for the transistor.

The values shown represent

• V_C = 57.1 mV
• V_B = 0.808 V
• I_C = 33.0 mA
• I_B = 4.19 mA

We can now circle back to verify our assumptions made at the beginning of the article that V_CE ≈ 0, β ≈ 10, and that we can effectively ignore the transistor in our load calculations.

First, we can verify the BJT transistor is indeed operating in saturation mode: V_E < V_B > V_C equals 0 < 0.808 > 0.0571.

Calculating the V_CE and β values, we get V_CE = V_C – V_E = 57.1 – 0 = 57.1 mV and β = I_C / I_B = 33.0 / 4.19 = 7.86.

For the load, the assumed I_C current would be V_CC / R2 = 5 / 150 = 33.3 mA and we got a value of 33.0 mA in our simulation.

And finally, the assumed I_B transistor base current is I_C / 10 = 33.3 / 10 = 3.33 mA and we got a value of 4.19 mA.

Overall, our simulation results are pretty close to our assumptions. Very good!

As an aside, I physically built the circuit and obtained the following measurements that correlate very well with the simulation.

• V_CC = 4.92 V
• R1 = 0.979 KΩ
• R2 = 149 Ω
• V_CE = 52.9 mV
• V_BE = 0.767 V
• I_C = 33.5 mA
• I_B = 4.37 mA
• β = 7.67

Viewing The Waveforms

In the previous section, we determined the circuit values from the SPICE simulation output text. A simpler way to see the values is to use the KiCad waveform viewer. Since we ran a transient analysis with .tran 1u 1m, the time frame for the waveforms will cover from 0 seconds (when the circuit turned on) up to 1 ms.

To view a signal, such as a voltage or current, click the Add Signals icon in the toolbar and select a signal you want to view in the popup window. Let’s start with choosing the current flowing through resistor R1. Click on I(R1) and then the OK button. The waveform will be shown in the waveform viewer on the left and the I(R1) signal will be listed in the Signals list on the right. The current will be about 4.19 mA.

To remove a signal from the viewer, double click the signal name in the Signals list.

Let’s next look at the transistor’s collector voltage by adding the V(/Vc) signal like we did earlier for I(R1). The value will be around 57.1 mV. Play around and look at some of the other signals as well. Close the Spice Simulator window when you are done.

Although we are seeing the expected values in the waveform viewer, the waveforms themselves are not very interesting. Let’s change it up a little by adding a 100 mV ripple to the input voltage.

Add a new VSIN voltage source (from the Simulation_SPICE library) to the schematic and edit the simulation properties to be those shown below.

This means we are applying a sine wave with a DC offset value of 5 V, an amplitude of 100 mV, and a frequency of 10 KHz.

Then, attach a global output label and a ground to the new VSIN voltage source similar to what we did for the VDC voltage sources. However, this time name the label as Vin2.

Finally, rename the Vin input of the transistor circuit to Vin2 so that we properly input the new sine wave voltage source. The new circuit should now look like the following.

Save the schematic and run the simulation again and the output text should be identical to the previous simulation, except for the inclusion of the new VSIN voltage source, since the ripple voltage we applied is about the 5 V DC offset.

View the V(Vin2) signal this time and we should see a sinusoidal waveform that oscillates between 4.9 and 5.1 V.

Remove the V(Vin2) waveform and view the I(R1) signal. You will see the current oscillating between 4.09 and 4.29 mA.

To determine a value along the sine wave, right-click on I(R1) in the Signals list and select Show Cursor from the contextual menu. A dashed axis will appear in the waveform viewer with I(R1) also showing up in the Cursors list. Click and hold around the origin of the axis and you can “ride” the waveform watching the Time and Voltage/Current values in the Cursors list change. Release the click when you are at an interesting point along the curve. To remove a cursor, right-click on the signal in the Signals list, and this time select Hide Cursor.

Again, play around and view some of the other signals.

Summary

In this tutorial, we learned how to run a SPICE based circuit simulation in KiCad. Specifically, we learned how to

• set up a schematic for simulation,
• create and apply models,
• add SPICE control statements,
• run a circuit simulation, and
• view circuit waveforms and determine certain values along the curves.

Running a circuit simulation is a good way to verify your design will operate as expected and enables you to discover and correct possible problems before implementing your circuit.

The final schematic used for this tutorial is available on GitHub.

Thank you for joining me on this journey and I hope you enjoyed the experience. Please feel free to share your thoughts in the comments section below.