I translate.
No, no, I directly plugged into the laptop.
Okay, so we are going to continue on.
The stream going out that is being recorded looks nice,
so the rest of us, we're going to suck it up
and just listen to what we are here to learn from Holger Voight.
So please give a round of welcome to Holger.
Yeah, okay, so many thanks.
Angie Spice, Circulator and Pink.
Talk about Stand-Alone and Embedded in Turkey Cat.
Well, I give a short introduction to Circulator.
Then talk about what's new in Angie Spice.
Talk about the Kikat-Angie-Spice interface
and give some simulation examples.
Well, conclude with what is next.
Yeah, why circuit simulation?
You emulate electronic circuits per software.
It should be cost efficient at time saving.
That's it.
Some details, of course, you can check functionality
without making hardware.
It's very important if you do IC design
because fabricating an IC with a defect circuit,
this is very expensive.
You can check for parasitic elements.
You can make variance very easily.
You can change some device parameters
and see what is happening.
You can evaluate new concepts with not too large an effort.
You can cross-check against automatic circuit generation
as a final simulation test.
You can anticipate reliability,
make degradation simulations.
And it's a good learning experience
because you can look into a circuit
without using hardware to do so.
You can see voltage and currents
in different branches in this.
Very interesting.
Yeah, Angie Spice, what is it?
It's a circuit simulator that numerically solves equations.
Describing electronic circuits,
it can also be other types of circuits.
For example, thermal could also be mechanical.
And you are interested mostly in time-varying signals
in electronics, its current and voltages.
It's the open-source successor of the vulnerable
SPICE-3 from Berkeley.
Okay, we have a circuit.
This is a very simple circuit,
an inverter with two transistors.
And this is the entry to Angie Spice.
So Angie Spice is a command line input tool.
Many people said, ooh, command line.
But I've just learned command line is very nice.
KeyCut has got a command line and other software also.
So we are not too bad with that.
Okay, you have the net list, the SPICE net list,
which contains circuit description, power supplies, transistors,
some simulation commands to run the thing
and some model data to run this thing.
The output is graphical indeed.
It's a time axis and the voltage axis.
The ideal green input.
Yeah, it's green still.
And the simulated output, you see the inverted signal.
Yeah.
This is the Angie Spice user interface.
Yeah, on the input side, you put in the circuit net list,
the circuit description.
You put in models or model parameters for the devices
you're using in your circuit.
And you put in simulation commands.
And the output could be data tables or tables to file,
of course, could be graphical plots.
We use the venerable X11 interface
or native Windows plotting capability.
Or you can plot to PostScript SVG
or use NuPlot or other tools for outputting.
Yeah, what's new in Angie Spice?
The current release is Angie Spice 42,
released in December 27th last year.
We have an additional matrix over.
I will talk about these things a little bit more in detail
in the following.
We have a new matrix over in addition to the venerable SPACE 1.3.
We support VariLock A-coded compact device models.
We allow co-simulation for mixed signal simulation
with VariLock digital circuit blocks
and mixed signal digital analog parts within Angie Spice.
We allow core simulation.
Again, mixed signal with C-coded digital.
So there is a way to translate C-code into Angie Spice readable
shared libraries.
And we have a, and I'm benefiting from the vastly improved
graphical user interface,
key cut, especially the upcoming key cut A is offering
for using Angie Spice.
Well, the matrix over.
What is the circuit simulator doing?
The circuit simulator, if you look inside,
Angie Spice gets the circuit, makes a setup,
parsing the netlist, reading the model files.
And then it is, if you do a transient simulation,
simulation versus time, then you have the ever circle here
between model equation evaluation and these data go
into the matrix and the matrix is solved.
And then you go for the next time step
and you repeat this until the time is over
and you look at the output.
The model evaluation is already running in parallel
in Angie Spice.
We use open MPs,
so if you have a multi-core processor
you typically have today, you use, benefit from that.
The matrix evaluation is not paralyzed.
These sparse matrix solvers are difficult to paralyze.
So we have been looking for a long time
for an additional matrix solver.
We used the sparse 1.3, developed in 1986.
And now we use an additional optional selectable KLU matrix
solver, which is ongoing development by T.A. Davis
and his co-workers.
And with KLU you get a speed-up of simulation
by factor 1.5 to 3 if you have large circuits
and especially if you do circuits for IC simulation.
And this is, of course, an advancement.
We allow Verlach A compact device models in Angie Spice.
Compact device models, these are the model equations
describing modern transistors, for example.
These complex, tiny things like FinFETs
also would have 500 parameters and lots of differential equations
to describe and people do the development in Verlach A.
And so we had a real need to have an interface to this Verlach A
because this provides access to the modern devices
like BISIM bulk, which is for ultra-short channels,
or BISIM CMG, which is for FinFET, or for gallium nitride devices,
power devices, high-speed bipolar transistors, and so on and so on.
Yeah, and we got this set up in cooperation with the company SemiMod,
who did this open-source development.
We have the Verlach A model description.
We compiled this model with an open-source compiler OpenWath,
compiled directly into a shared library,
and this shared library can be read by Angie Spice,
which has got the OSDI interface.
So we are reading directly the Verlach A compiled model
from a shared library or DLL.
Yeah, we make use of this.
For example, I've been mentioned maybe already,
open-source PDK is for IC design,
are upcoming, and one of these is the IHP open-source PDK,
and this is a 130-nanometer CMOS process
with integrated ultra-fast bipolar transistors.
Ultra-fast means 500 GHz or so.
The model used for the bipolar is the so-called phobic model,
which is integrated into Angie Spice for some years now,
and the MOS model is a PSP model developed by,
currently I think developed by Lehti in France,
and this is Verlach A, and we translate this,
put this into Angie Spice,
and so we can support this open-source PDK with simulation.
This is just a simple example, 19-stage NAND gate ring oscillator,
so we have 19 NAND gates in series,
feed them back, and it starts to oscillate,
and we have your frequency,
this is an FFT of this signal, a frequency of 600 MHz,
and you divide it by 19 by 2,
and then you get an inverter delay of 280 picoseconds.
Okay, yeah, we allow digital Verlach circuit blocks into Angie Spice.
Looks a little bit more complex, but isn't that much complex?
We have a Verlach digital circuit block.
We compile this with an open-source compiler very later
into some intermediate C code,
and then we compile this intermediate C code
with some C templates in addition,
which are constant all the same.
We compile it with GCC or MSVC into a C-CodedShare library.
And this C-CodedShare library is read by Angie Spice.
Angie Spice has a so-called code model interface,
and we have written a code model in decosim,
which directly interfaces this shared library.
So we can now run simulation with this standard Angie Spice netlist,
which may contain lots of analog, plus digital blocks.
This is an example, it's just a demo,
it's not a productive simulation.
This is a successive approximation register analog to digital converter.
Six-bit.
And this uses the digital SARAR block written in Verlach
with the analog part, which is a capacitor array with some switches.
Okay, and even if things look complex,
using this is not very complex.
You need two commands.
You have this command, Angie Spice,
and Angie Spice calls a script written in Angie Spice control language,
and you enter the ADC Verlach description.
It compiles the Verlach thing, it compiles the GCC thing,
and then you call the Spice netlist with the standard command,
Angie Spice ADC dot sir, which contains the analog part
and contains the simulation control,
then you get this kind of thing.
Okay, I just enlarged a little bit.
You see that it's a successive approximation.
This is the ramped-in voltage, and this is the x-axis is time.
And this is a new start.
We try to get the value of this point here.
It starts with the starting value,
and then successively approximates the input.
Well, with a certain delay, 8.5 microseconds here,
which is the time you need for the conversion,
then you are here in the stable phase,
and this is the red line just shifted by 8.5 microseconds,
is, well, the output signal.
Yeah, so digital plus analog.
Okay, you can also do this with C-coded digital type of models.
You have C-coded independent processes.
You compile them with GCC, for example,
or with any C compiler.
And these communicate with NG-spice via another code model.
The digital interface is now called deep-process.
Well, this has been developed by Eurospalatis
from Isotel some time ago,
but we have now, for the recent version,
have adapted it a little bit,
modified it so it will also run under MS-Windows.
And now we can, yeah, simulate some circuit,
which has some circuit blocks from C-code.
This is just, again, an example, a simple example.
The C-code you see here, this is, yeah, a gray code generator.
This gray code generator is compiled
and loaded into NG-spice,
and this is the output.
The plotting here is by GTKWave,
because this is a nice digital plot.
Yeah, and you can use these kinds of blocks.
So you define these compute functions with data out
and data in and some other,
and the time or the clock circuit, clock going in,
you can run C-code digital circuit.
Okay, so I want to talk about schematic entry for NG-spice,
because this is under continuous development,
and, yeah, it's a nice usable thing.
Why do we want to have such a graphical user interface?
Well, NetList as input quickly becomes confusing.
You need schematic entry.
You need to see circuits,
circuit schematics,
and then have an interface to the simulator.
You can get better documentation, of course,
if you group inputs and outputs.
This is not an NG-spice development.
So we develop this, for NG-spice,
don't develop these graphical user interfaces.
We make use of existing ones
or support the development.
And, of course, you need one,
because all other simulators are mostly,
most of all other simulators have one,
so you have to offer one.
There are three of these interfaces
currently under development,
we cooperate.
This is a thing called X-Schem,
whose main focus is on IC design.
There is another one, QXS.
This is a very universal interface,
which specializes a little bit in RF simulation.
And then, okay, we have the key-cat.
So I wouldn't say that key-cat is developed
because it's a graphical user interface of NG-spice.
No, the other way around, yeah?
You have heard about this PCB design and layout tool,
and it offers a simulation,
and the simulation engine is NG-spice
to support the circuit designer.
So, of course, I can then make use of this beautiful interface.
Okay, just show these interfaces in strange colors.
Yeah, I won't talk about these.
I want to talk about this one, again, in strange colors.
Okay, but you could imagine that it could look nice.
This is the ischema window with some circuit,
simple circuit, a simple phase shift oscillator
with a 4.2 kHz frequency oscillating.
And down here, you see the FFT.
Of course, you see it's not a super clean sinusoidal signal,
but, okay, this is the 4 kHz thing here.
Yeah, so what is the interface looking like?
Ischema does this schematic entry.
Ischema generates the SPICE netlist,
and Ischema also does a graphical presentation of the results.
So, it sends the circuit netlist to NG-spice,
it sets model parameters to NG-spice,
so the simulation commands,
and it gets back simulation results.
NG-spice is here used as a shared library
to this key-cut process.
Yeah, I would like to make a live demo.
I don't like these colors,
but let's see if we can survive somehow.
Okay, this is my starting template.
I do not start from the zero because it takes too much time.
So, this should become an operational amplifier.
Simple thing, amplifier by a factor of 10.
Okay, what is missing is the operational amplifier.
I try to grab it, grab it from the library.
So, we just load the library,
it takes a little bit of time,
but only once the first time, then it gets faster.
I know that it is in the library simulation-spice,
and here is the op-amp.
I grab it, and I move it,
and hopefully it fits because, yeah, it did last time.
Yeah, it does.
Okay, so this is how you place additional elements.
Very simple.
But now, let's stop.
We don't need any more, I hope.
Yeah, and now we do simulation.
This is a real-time simulation.
I look inspect for simulator,
and I get this simulator interface.
Well, black is green, and pink is white.
Okay, I'm sorry for that.
What do we want to do?
We want to do the transient simulation.
Transient simulation is output versus input versus time.
Okay, and so we have, yeah, what is our input?
Let's go back and have a look.
The input is a sinusoidal signal
with an amplitude of 0.1 volt
and a frequency of 1 kilohertz.
Okay, back to the simulator window,
and I just click on to start simulation,
and here is our simulation.
The input is the small one,
and the output is the red,
who stays red.
That's great.
The input is the red signal.
Okay, so this is transient simulation versus time.
We could have another simulation.
To be honest, I have prepared this.
Four, this is so-called AC simulation,
small signal simulation versus frequency.
So you see the frequency behavior of this kind of circuit.
Yeah, we again run the analysis,
and you see that the amplification is 20 dB,
so it's 10, is constant,
but the operational amplifier has one single internal pole,
and so it goes down.
Okay, so this is very quickly,
you just see what's going on.
I think I have time to make some additional change.
I put an additional capacitor in here.
I collect my capacitor,
I transform it because I have to rotate it.
I put it just in here.
Let's do it in here.
And I have to give it a value.
I guess I take one mic one.
Yeah, and then we go back,
and do the AC simulation again.
Oops, there's something changed.
We have this, this is sort of low pass behavior.
It stayed, and now we have some high pass behavior
for the low frequencies due to this input capacitor.
Yeah, so very quickly you do a small change,
and with a simple click, we are there.
Okay, so this is what I wanted to show live.
Let's go back to the slides,
and I give some more examples.
Yeah, the first example, this is, again,
why do you want to simulate?
This is a 2.5 kilowatt class D audio amplifier.
And you would say, this is strange.
No, you go to some Amazon and click in
looking for these kind of amplifiers and 300 bucks.
You can get a kilowatt amplifier today,
because it's a digital amplifier.
And, okay, so what did I do to get this simulation?
Okay, I made a symbol myself of this audio driver circuit,
just drawing the symbol.
And this audio driver circuit is also something
I created myself, because it has the analog input.
It has a path width modulator.
This is a translation from the analog signal
to a pulse width digital signal.
It needs something more.
It needs a complementary pull output,
because we have two transistors here.
And it has a dead time generator to avoid shoot through,
because what will happen?
You have minus 100 volts here, plus 100 volts here.
And if you manage to open both of these transistors
at the same time, you will see the result in form of smoke.
And so you have to avoid this.
And, okay, and some simulation commands in here.
The input is 2 volts, again, 1 kilohertz.
You see the power supply.
The output load is a 2 ohm resistor.
Well, and this is the output.
This is the input signal, and this one is the output signal.
Okay, and with the double frequency,
you have the power signal, the blue one here.
And if you do an RMS over this output power signal,
you see here it's kilowatt up to 4.3, for example,
you will get an output power of 2.6 kilowatt.
The simulation has a great advantage.
Nothing explodes.
You can just do it, and if you do,
you can investigate the output filters
and can check loudspeaker models and everything just by simulation.
Of course, you can also do real-time real amplifiers.
This is Tiberio Vecol has made this Q17 amplifier
derived from the famous quad 405 audio field amplifier.
You see lots of transistors in this thing.
The output stage, the input is an operational amplifier.
This is the modern contribution of the whole thing
and some voltage generators here.
Well, yeah, and you can, of course, simulate this
and look similar to our 2.6 kilowatt, it's 100 watt,
and what you see here is just at 300 milliseconds,
we switch the output load from 8 to 7 ohms automatically
to check what the output load would mean,
and you see a little bit increase in output power.
So you can model all these things and model the influences and so on and so on.
OK, NG-SPICE allows to do mixed signal simulation.
Mixed signal simulation means you have analog and digital circuits
in the same simulator, and you could also simulate the digital part
like the analog part, but this takes a lot of time,
and if you have more than a few gates, it would be much too slow.
So NG-SPICE includes an event-based simulation, which is very fast,
and this is a mixture.
Well, this is the veneral 7400 series of devices.
You have flip-flops here, you have some output decoders
and some NAND gates, and you have some XOR, or NAND, this is NOR gates.
Yeah, and you can simulate this whole thing together,
and you see that this is mixed signal means
because we're using the digital output here for a delay line.
So we have an RC delay and another RC delay,
and we have the original signal,
and so this gives an output pulse of a specific width.
This is the clock signal generated in this circuit,
and this circuit here, which is shown, is a rotary encoder,
so encoder which does give optical signals when it's turned around one or the other way,
and this is the digital output, again plotted with GTK wave,
and you see this here, the Q1 signal is coming before Q2 signal,
and because in the rotary decoder these two decoders are shifted a little bit,
so you know that this is turning left, for example,
and here the turning is changed to the other direction,
and you see the Q1 is coming later than Q2,
and this is detected by this circuit.
You have here the pulses, let's say for turning left,
and then left turning, switched right turning,
and you see the output pulses here for the turning right.
So mixed signal simulation is, and this is effective,
because the whole simulation thing is 25 milliseconds,
so it's ultra-fast, it's click, and it's there.
You can even run this on this computer here,
which is not the fastest machine.
And we can have pure digital.
I made a symbol for this up and down counter.
You have the input clock, you have the input up and down signal,
and here it's a 3-bit, 8-state counter,
and inside of this is a state machine,
and it's a very, very simple state machine.
You have here the states from 0 to 7, so the 8 states.
Here are the signals you see from 0, 0, 0 up to 1, 1, 1,
and here is what the states are switching.
The input is at 0 state, and the input is 0,
input means backward counting,
then the next state is this one here.
Or if the input is 1 and we are at state 0,
then we go to state 1.
If we are at state 1 and we count down,
we go back to state 0.
If we are at state 1 and we count forward, we go to state 2.
So you can do very simple programming inside one of these code models
used by the digital event simulator of NG-SPICE.
Well, and here's just the signal, the clock signal.
This is the up and down, the up and down signal,
and we count up and count up, and then we switch to down
and then we count down and we switch up again.
So very simple simulation, and the simulation time
of this whole thing is mere 37 milliseconds,
so it's very fast.
Okay, so much about the examples we have.
What's next in NG-SPICE?
Here are listed some ideas, some more or less fixed plans,
and some actual activities.
We will do more tests with the open source PDKs,
supporting the sky-water PDK,
and especially the upcoming IHP PDK
to support analog mix signal and RF simulation
to support these kind of designs.
We will improve the RF capability by adding harmonic balance
with a special effective method,
for example, to simulate intermodulation of signals and so on.
We will support reliability and degradation simulation.
Well, nothing lasts forever, chips don't last forever,
and people sometimes want to know how long they will live,
and so you can try to model that, and this will be done here.
And hopefully with a funded project, this is very interesting.
There has been the request for transient noise simulation.
This is a difficult task,
because we don't want to rewite the complete simulator,
we have to figure out ways, and again here it would be
very difficult to do that.
If somebody is interested in integrating this into NG Spice,
please let me know.
We will improve the usability of key-cut NG Spice graphics interface.
Continuously, people are requesting things,
and we are detecting things,
and we can try to simplify things,
we can try to support more of what NG Spice is offering internally right now.
For example, the digital simulation is,
should be supported by having digital basic blocks as input,
and digital plotting, for example, as output.
And we have to enhance compatibility,
because the world is, somehow we are competing against commercial simulators
like LT Spice or Q Spice, or P Spice, or H Spice, and what other...
We cannot do this in full,
but the basic things should be compatible.
But all these four I have mentioned have different,
slightly different input languages,
slightly different models,
and so you have to take care of this somehow.
Yeah, that's it.
What I wanted to provide you with information,
here is some support,
websites, if you need more details,
here they are.
Thank you.
APPLAUSE
So, while we are taking questions,
the video team is going to try to repair the video locally,
so your questions will not be able to refer to the slide.
Hi Holger, you said something about the creation of semiconductor devices.
Would it be possible to simulate the creation based on radioactivity?
Yes, this is included in this development plans.
Thank you for the presentation.
A quick question is how do we input the state machine in the component?
Is there a special window where we come and we type it,
or the state machine must be written in a dot c or dot something
and we give it to the component?
Yeah, the simple state machine,
the question is how can we code the state machine into ng-spice?
The simple state machine I have shown is just a text file.
This text file is loaded, you put into your spice netlist
a single line with a specific model and this model loads the state machine.
That's it for the simple things.
The complex, you could of course write state machines and c-codes if you want to.
Then you have to do this translation.
My question is maybe a bit naive, but would it be at some point feasible
to include the tracks or geometry inputs from KCAD
in order to mimic the links that you place between your spice components?
Please, it's a little bit...
Track width and we also have the PCB stack up.
Would it be somewhat feasible to from this geometry inputs
associate a kind of approximation of the S-parameters of each lines between the components?
Yes, there is some work ongoing.
It's not that intensive to use an EM-sover, it's called Sparse Lizards,
to extract these data from your lines in KCAD.
I think it's a lack of manpower to make this a real tool.
KCAD has added IBIS simulation, so you have IC output and IC input,
only the output and input signals and many semiconductor vendors offer these models.
Then you could basically have a transmission line or an RC line in between
to simulate the signal integrity.
The problem is, as you said, to get these data from your PCB.
Slowly, slowly moving on.
Basically, yes, but this is a key-cut or ischima, it's a key-cut work,
it's not the NG-spice. The NG-spice takes the transmission line parameters
or takes the parasitic capacitance resistances and then does the simulation.
So the EM would have to be data from the key-cut?
Yes, exactly. The EM has to come from the key-cut.
I wanted to ask if anybody has used the C interface to, for example,
make simulations of existing microcontrollers or things like that
that you could have in your design.
There has been some activity on this, very scarce.
I think it's two. It's yours, Platysy, from Iso-Tel.
Just look up his website, Iso-Tel, and you could find some information on that.
There has been another guy, I think he has used Arduino interfacing to NG-spice,
but I don't know much about this work.
Are there any dynamic languages that are possible to be used as a model,
or is it just compiled languages that have to be loaded?
If you don't care about simulation time, for example,
would it be possible to use any scripting language to...
Yes, there are various kinds of making models.
You have the very old A-road, but this is compiled and static.
And it's compiled, it's there.
You can do models with NG-spice internal nonlinear voltage sources, for example.
And these are very dynamic.
And many power semiconductor device makers,
they make so-called sub-circuit models, which are comprised of spice commands.
These can be very complex, difficult to debug,
but then you can do whatever you could imagine.
Is it possible to perform simulations over PVT, so over process variants and voltage variants?
Yes.
And would it be possible to do this without changing any of the models itself?
Yes, this is the typical content of the model.
Content of modern semiconductor PDKs when you think about IC simulation.
The worst case simulation or corner simulation is typically integrated.
It's different model parameters.
The model stays the same, but certain parameters are changed.
So we have a question from online.
Just heads up, we're still working on the video, so lucky for us.
Holger is able to continue answering questions for the foreseeable future.
Online they are asking, is there any post-processing of waveforms such as THD, FFT, etc. possible?
FFT is standard.
FFT is standard in NG-spice and is standard in the Kikat-NG-spice interface right now.
It's more or less two clicks and then you have it.
You can set up, NG-spice has a very powerful scripting language, well another language.
It's not Python, it's another language which originated in 1990.
So we keep it up and have more than 100 commands available.
And you can do a lot of data processing with this scripting.
So for example, classification into bins, or if you do Monte Carlo simulation, you can run Monte Carlo simulation.
You can classify these data into bins.
You can do a lot of post-processing internally in NG-spice.
Well, of course, if this is not enough or you want to use standard interfaces,
there are Python-NG-spice interfaces available.
So you can use all these Python libraries which are there for data processing.
So it's a lot of action, but the action has to be done by you.
Okay, we have time for one more question.
You do not actually work time.
Okay, so let's give Holger a round of applause.
Thank you very much.
Okay, so we're going to check.