For as long as I can remember I was always mesmerized by high voltage, at the same time as being extremely afraid of it. I still remember visiting the German Museum in Munich as a kid and wanting to see the HV demo there, but being so afraid, that I never actually set foot in the hall with the demo setup. So from that it kind of makes sense that the first electronics project (excluding playing around with some Arduinos) that I ever undertook was to build a Tesla coil, because it is relatively safe (more on that further down), but still makes some impressive arcs. But this first version was just a copy of a instructables manual, only ran at 30V input and was always a little pathetic.
So after getting an old induction cooker and turning it into a shitty Tesla coil (that actually worked quite well), I decided to scale up the design and build a large(er) one.
I am not going to go into the theoretical basics of Tesla coils here, since there is a lot of good info on that out on the Internet already (just search google for something like “how does a Tesla coil work”), and will instead focus on the pitfalls and traps for young players I encountered during the build.
The topology I chose is probably the most common one in the land of medium to large sized coils: a DRSSTC (Dual Resonat Solid State Tesla Coil)
So what the heck is that even? As you know (or just read about :P) a Tesla coil is a resonant driven transformer, but the way the resonance drive is accomplished varies from design to design. In a DRSSTC there are two (Dual) resonant circuits; one is the actual coil and the other is a LC resonant circuit with the primary and a capacitor in it. This primary resonant circuit is then tuned to match the frequency of the secondary and achieve resonance. It is easier to do than trying to use an antenna for the feedback loop of the driver, because we can use a current transformer on the primary, that gives us a nice and solid frequency and phase reference to drive the transistors with. So the controller basically only drives the primary circuit at resonance, and the secondary just happens to match the frequency. Those transistors are either in a half or full bridge, depending on how much power you want to push through the coil (a full bridge can generate twice the voltage swing of a half bridge).
In my design I went with a full bridge, using four miniBlock IGBTs, with a peak current rating of 470A, that are driven by two gate driver ICs. The same topology as the induction cooker used (I combined two of its half bridges into a full one). For the controller I could have just used one of the many existing designs, from people like Steve Ward, or even bought an off the shelf one from aliexpress. But because I always like to design my own stuff, I did it the hard way and started from scratch.
In theory the controller is very simple: check in which direction the current is flowing, and then switch on the right transistors:
But there is a lot more to it. Apart from things like OCD (not Obsessive–compulsive disorder 😉 but Over Current Detect) that protects the transistors from damage by a too long enable pulse or lack of energy transfer to the secondary, and an input for the interrupter signal (basically a pwm enable signal, because DRSSTCs don’t usually run continuously due to current consumption and power dissipation concerns), there are a few tricks used to get more current through the transistors than they are designed to switch safely.
How? By simply not switching when there is current flowing. Basically the goal is to switch the transistors as close to the zero crossing of the current as possible. Less current while switching means lower losses, and (to a point) the ability to exceed maximum ratings in the datasheet.
But of course there is the issue of propagation delays in the logic used, for example in my coil I had a few hundred nanoseconds plus the dead time of 1us between actual zero-crossing, and the transistors being switched (which caused death).
So you effectively need to switch before the event that triggers it even occurs. How can we do that without using 1.21GW each cycle? Simple, since we have a periodic waveform, we can just use an RC network to phase shift the signal forward, allowing us to actually see into the future 😛 . I adjusted this, to get a phase lead that matches the time delay caused by the dead time of the IGBTs and the propagation delays in the logic.
Note: primary current here is very limited, since it was for testing. Usually the peak is ~330A
As you can see, the switching occurs just before the zero crossing
Once the controller does what we want it to, we still have the task of driving the gates of the IGBTs in the bridge properly. The issue here: the entire bridge is mains referenced, so we need to isolate it from the controller circuitry, in case we want to probe something and to prevent a fault from blowing up everything. I used an isolated gate driver for this task. it has two channels and plenty of isolation, though a normal optocoupler would have been fine too. This signal then goes into the gate driver ICs, basically a very strong buffer that allows for fast charging and discharging of the (Capacitive) gates. But we somehow need to get +15V with reference to the output, for the top transistor, so how do we get that?
A commonly used approach is a bootstrap capacitor, that charges up through a diode when the bottom transistor is on, and then rides the voltage up with the output and provides the necessary charge for the gate.
C: simplified charging.
R: simplified switch on. The con. from cap to gate is in the driver IC
As you can maybe see, there is a problem here. The current we have flowing is on the order of a few hundred amps, so there will be a significant voltage drop across the transistors. But the bottom transistor (QB) is in series with the capacitor when it is being charged, so any voltage drop across it would reduce the voltage at the capacitor, and thus also reduce the gate drive voltage of the top IGBT. When the gate voltage drops below ~13.5V the IGBT gets de-saturated and a large voltage drop across it develops (at the 300A+) , which leads to heating and, if the heating is enough, failure. But whats the margin? If you look at the diagram for the charging capacitor, you can see that in series with it is a schottky diode, a low value resistor (to limit peak current) and the bottom IGBT, so with 15V supply, the maximum allowable drop across these is 1.5V. Even if we ignore the resistor and the diode, we only have a maximum drop of 1.5V until the top IGBT starts to get cooked.
If we look at the curves in the datasheet you can see that that would occur at only 60A, a far cry from the 300A-500A that will be flowing in the circuit.
So do we have to decide between medium or well done IGBTs or is there a solution?
Of course there is 😉 . We need to increase the 15V supply to something like 20V, to give adequate margins for the top transistor, and at the same time fry neither the gate of the bottom transistor nor the driver chip, which both have an AMR of 20V.
I had a few dead IGBTs until I figured out this was an issue with the help of people on the High Voltage Forums.
Before I could even get to fixing that issue though, I first had to design the bridge; the first design was lazy and naive, the second one was a little better and the third is the one that is in the coil at the moment. The first had a few flat pieces of copper tubing between the IGBTs and just generally terrible layout. The long leads from bulk capacitors (and their inductance) combined with the lack of local low ESL/ESR decoupling resulted in voltage spikes that killed the IGBTs. That or the lack of deadtime control in the driver chips…
Second revision added dead time and tightened the layout of the power connections, but still no film caps for decoupling.
And then the third revision had decoupling and dead time. I even did the mechanical design in CAD to make sure everything fits together as tightly as possible:
The last mistake one might make (but i actually didn’t for once 😛 ) is the lack of capacitor pre-charging. A capacitor bank of this size (4x3300uF @ 350V) has so much energy storage that the charging current without a ballast resistor would instantly trip any breakers, or at least be very bad for the caps. Also they will keep this (LETHAL) charge for a long time, so they need to be safely discharged after use, incase a curious engineer (me) decides to touch it for some reason. For this I made a power board with two halogen lamps on it. One for charging and one for discharging. There are two relais (for bigger coils contactors) switching of the discharge lamp once mains power is applied and bridging the charging lamp after some time has passed (enough to have a full charge on the Cap. bank). This timing is handled by a 555 Timer circuit and an opto-triac in the controller. I did however neglect to add a snubber across it in the first revision, which caused the shorting relay to activate immediately once power was turned on, if that happend to be near the top of the mains waveform. But because the capacitor had practically no time to charge, the relais effectively shorted the mains supply out, causing the contacts to get welded together in both relais on the board, and also preventing any accumulated charge in the bank from being discharged (this could have been prevented had I connected the relais more intelligently).
Adding a snubber fixed that issue.
(not screwed down) PCBs. The center one is the power controller board
So now that all of the components work, we have a functional tesla coil! So far I was still running from an old audio amplifier’s transformer, so was limited in power output, but the sparks are still impressive:
If you want the full resolution image, just click on it.
You’re free to use them as you desire, but I’d be happy if you sent me a message about where, if you do 🙂
Now I just need to make the base look good, and be portable, and the project is “finished” (though I probably keep changing things around for ever 😛 ).
As an accompanying project I designed a small usb stick sized midi interrupter, that allows me to play music through the coil, controlled by a midi player on a PC. If you are interested you can check it out here
I uploaded some of the tests of it to youtube if you want to hear how it sounds:
There are more test on my youtube channel (and also an autopsy of two of the IGBTs that blew up, though that video is quite long)
