Rockin’ Out In LTSpice: Simulating Classic Guitar Pedals

October 29, 2020 by Adam Zeloof 9 Comments

Musicians have a fantastic language to describe signals. A sound can be fat, dark, crunchy, punchy — the list goes on. These aren’t very technical terms, but they get the job done. After all, it’s much easier to ask to guitarist for a crisper sound than to ask them to sharpen the edges of the waveform, while amplifying the high-frequency components and attenuating the low-frequency components. Of course, it’s fun to look at signals this way as well, especially when you can correlate shifts in sound quality to changes in the waveform and, ideally, the circuit that produces it.

To undergo such an investigation, [Nash Reilly] has been simulating guitar effects pedals in LTSpice. Able to find most of the schematics he needs online, [Nash] breaks down the function of each part of the circuit and builds a simulation of the entire system. His write-up clearly explains, and often demonstrates, what’s going on inside the box. On the surface, it’s an interesting tour of the inner workings of your favorite effects pedals. Beyond that, it’s an excellent survey of analog design that is well-worth the read for anybody interested in audio, electronics, or audio electronics.

For those interested in taking the physical route rather than the simulated one, we’ve taken a look at pedal design before. Anybody who wants to try their hand at creating simulations can grab a copy of LTSpice, or check out a package called LiveSpice, which lets you simulate circuits in realtime and use them to process live audio — pretty useful for prototyping guitar effects.

TI And Cadence Make PSpice Free

September 20, 2020 by Al Williams 28 Comments

We like simulation software. Texas Instruments long offered TINA, but recently they’ve joined with Cadence to make OrCAD PSpice available for free with some restrictions. You’ve probably heard of PSpice — it’s widely used in academia and industry, but is usually quite costly. You can see a promotional overview video below.

The program requires registration and an approval step to get a license key. The downloaded program has TI models along with other standard models. There seem to be few limits as long as you stick to the supplied library. According to the datasheet, there are no size or simulation complexity limitations in that case. If you want to use other models, you can, but that’s where the limitations hit you:

There is no limitation of how many 3rd party models can be imported into the design. However, if 3rd party models are imported, a user will be able to plot a maximum of 3 signals at a time of their choice when any 3rd party model is imported from web.

We aren’t completely sure what “from web” means there, but presumably they just mean from other sources. In any event, you still get AC, DC, and transient analysis with plenty of options like worst-case timing analysis. Mixed signal designs are supported and there is a wealth of data plotting options, as you would expect.

This is a great opportunity to drive some serious software that is widely used in the industry. The only thing that bummed us out? It runs under Windows. We couldn’t get it to work under Wine, but a Windows 10 VM handled it fine, although we really hate running a VM if we don’t have to.

Still, the price is right and it is a great piece of software. We also liked the recent Micro-Cap 12 release, but we don’t expect any updates for that. Of course, LTSpice is quite capable, too.

Continue reading “TI And Cadence Make PSpice Free” →

Solid State Relay Simulation, Explained

February 19, 2020 by Al Williams 16 Comments

[SaltyPuglord] needed a solid state relay for a project. We’d have just bought one, but he decided to design his own in LTSpice. Along the way he made the video below, which is pretty informative and a good example of a non-trivial design in LTSpice.

MOSFETs have made designs like this a lot easier, to the extent that it should be as easy as putting a pair of beefy fets in-line with the AC source and load. However, that has a few ramifications that [Salty] covers in the video.

The biggest concern comes in isolating the DC supply from ground. He used a transformer which is tricky to simulate in LTSpice. Beyond that the design of the power supply is quite simple, and as he mentions in the video, you don’t really need this complex of a regulator just to feed the gates of the MOSFETs.

Continue reading “Solid State Relay Simulation, Explained” →

Commercial Circuit Simulator Goes Free

January 8, 2020 by Al Williams 118 Comments

If you are looking for simulation software, you are probably thinking LTSpice or one of the open-source simulators like Ngspice (which drives Oregano and QUCs-S), or GNUCap. However, there is a new free option after the closing of Spectrum Software last year: Micro-Cap 12. You may be thinking: why use another closed-source simulator? Well, all the simulators have particular strengths, but Micro-Cap does have very nice features and used to retail for about $4,500.

The simulator boasts a multipage schematic editor, native robust digital simulation, Monte Carlo analysis, 33,000 parts in its library, worst-case and smoke analysis, Smith charts, and it can even incorporate spreadsheets. There’s a built-in designer for active and passive filters. Have a look at the brochure and you will see this is a pretty serious piece of software. And now it’s at least free as in beer.

Continue reading “Commercial Circuit Simulator Goes Free” →

Circuit Simulation In Python

November 30, 2019 by Bryan Cockfield 23 Comments

Using SPICE to simulate an electrical circuit is a common enough practice in engineering that “SPICEing a circuit” is a perfectly valid phrase in the lexicon. SPICE as a software tool has been around since the 70s, and its open source nature means there are more SPICE tools around now to count. It also means it is straightforward enough to use with other software as well, like integrating LTspice with Python for some interesting signal processing circuit simulation.

[Michael]’s latest project involves simulating filters in LTspice (a SPICE derivative) and then using Python/NumPy to both provide the input signal for the filter and process the output data from it. Basically, it allows you to “plug in” a graphical analog circuit of any design into a Python script and manipulate it easily, in any way needed. SPICE programs aren’t without their clumsiness, and being able to write your own tools for manipulating circuits is a powerful tool.

This project is definitely worth a look if you have any interest in signal processing (digital or analog) or even if you have never heard of SPICE before and want an easier way of simulating a circuit before prototyping one on a breadboard.

Simulating A Speaker

November 20, 2018 by Al Williams 21 Comments

Speakers are one of those components that are simple to use, but difficult to simulate. Most of us have used a simple resistor to do the job. But a speaker’s response is much more complex, and while that might be enough for a simple simulation the fidelity is nowhere near close. [Sourav Gupta] recently shared his technique for modeling speakers and it looks as though it does a credible job.

[Sourav] shows how a simple resistor and an inductor can do the job, but for better fidelity you need more components to model some mechanical effects. The final model has six components which keeps it easy enough to construct but the problem lies in finding the values of those six components. [Sourav] shows how to use the Thiele-Small parameters to solve that problem. Speaker makers provide these as a guide to low frequency performance, and they capture things such as Q, mass, displacement, and other factors that affect the model.

Continue reading “Simulating A Speaker” →

Circuit VR: Measuring With LTSpice

August 23, 2018 by Al Williams 12 Comments

Usually, with Circuit VR we look at some circuit in detail with simulation — usually LTSpice. This one will be a little meta because I wanted to look at a capability in LTSpice which ironically is very useful, but not often used. Along the way, though, we’ll look at why you get maximum power transfer when your source impedance matches your load impedance. This is something you probably already know about, but it is interesting to look at in simulation if you know how to coax LTSpice — no pun intended — into showing you a meaningful graph.

The circuit is super simple. An AC source and a 50-ohm resistor stand-in for a 40-meter ham transmitter. With 100 volts into a 50-ohm load. So far, so good.

Continue reading “Circuit VR: Measuring With LTSpice” →