Engineer meets Bugera V22 reverb – Part 1

The Bugera V22 guitar amp is just too good to leave alone. Yes, it’s had its share of teething problems—the worst of which I believe have been sorted. Yes, it’s made in China. Yes the tube quality seems to be a crapshoot. But the build quality is better than what I’d expect at the price, and the sound is unique and just lovely. It’s a great buy.

One thing I’m not super jazzed about though is the amp’s reverb. I begin documenting my gripes below and start off in search of a solution.

It develops …


Picking up from earlier, what we’re looking at here is an audio DAC reconstruction filter built around a prototype discrete opamp-like differential gain cell I’ve had in the works for quite a while. I finally chased out the last engineering details and have been listening to the final setup for about a month. I am still astonished at how good it sounds.

I designed the gain cell from the ground-up as a dedicated high-performance audio device. It uses some novel topological and other features that I’ll probably go into in a future post. For now all I want to say that the thing is wicked fast for a discrete device and has been rock-solid stable.

But why bother? Aren’t there already tons of reasonably decent, some even cheap, audio IC opamps out there? Yes, there are. But I’ve never been totally happy with any of them. Some have too much LF bloat, some are too strident—none to my ears do everything right (which is to say, do as little as possible apart from making the signal bigger and stronger).

Designing a discrete device let me optimize the gain structure specifically for audio, minimize and more effectively manage the number of parasitic interactions throughout, thermally couple and, more importantly, decouple elements as necessary, and a few other things. It started as a “Gee, let’s see…” exercise, and I have been rather shocked by the results.

Now I’m contemplating where to take things next. I’ve designed a couple small-footprint packages for the gain cell. I’m implementing a few other ideas with it too. I suspect this surprising little circuit will see some commercial application soon.

Right then. Back to listening. 😀

PDF output from KiCad in Linux from SVG


The ps2pdf-d script I developed earlier worked fine for getting PDF from KiCad‘s Eeschema using Postscript as an intermediate format, but it falls short with Pcbnew because there is no way in Pcbnew to make a Postscript file that merges layers. Using File > Plot, you can pretty easily get Postscript files of individual layers, but you can’t get a merge of, say, the top copper, top silkscreen, and drawing layers.

But you can do this with File > Print SVG. You’ll need to play around with the dialog to get the SVG you want, but it’s pretty simple. Thus, svg2pdf-d was born:


# DESTRUCTIVELY convert all svg files in working directory to pdf.
# Source file extension is case sensitive!

# Requires inkscape.
# Mithat Konar 2013 <>


FILES=$(ls -1 *.svg)

# There are two alternatives below for doing the conversion.

#~ ## BEGIN ALT_1:
#~ ##     This approach isn't optimal because it restarts inkscape per
#~ ##     file. However the simplicity lends itself to porting (e.g., to
#~ ##     windows BAT.
#~ for file in $FILES
#~ do
    #~ base=$(basename $file .svg)
    #~ inkscape --without-gui ${OPTIONS} ${file} --export-pdf=${base}.pdf
#~ done
#~ ## END ALT_1

##     This approach seems to be better because it starts one inkscape
##     instance for all files, but it also involves a temp file.
# Make a temp file to store batch commands.
CMDFILE=$(mktemp) || { echo "Failed to create temp file"; exit 1; }

# build up the list of commands
for file in $FILES
    base=$(basename $file .svg)
    echo "${file} --export-pdf=${base}.pdf" >> $CMDFILE

# Process commands in a batch.
DISPLAY= inkscape ${OPTIONS} --shell < $CMDFILE rm -f $CMDFILE echo ## END ALT_2 # Delete old files. # Since inkscape exits with 0 even with errors, we need to explicitly check # for conversion before deleting originals. rv=0 for file in $FILES do     base=$(basename $file .svg)     if [[ -f ${base}.pdf ]]; then         rm $file     else         echo "$file not converted." 1>&2
exit $rv

svg2pdf-d requires Inkscape, which is not really that light. But it’s arguably something that should be in your FOSS toolkit anyway.

The Inkscape conversion used in svg2pdf-d seems to work fine with the SVG files generated by Eeschema as well. I’m seeing only minor differences between the SVG→PDF versus PS→PDF conversions, and the SVG→PDF files appear to have truer color. So the SVG approach may be the better one in general.

I’ll add I have added this to the wiki after a bit more testing making significant revisions.

Getting good PDF output from KiCad in Linux

Update: Turns out SVG might be a better base than PostScript for this. See PDF output from KiCad in Linux from SVG.

I’ve tried to get decent PDF output from KiCad‘s Eeschema a few different ways, but what I’ve found to work most reliably is to first export to PostScript (File > Plot > Plot PostScript) and then use the ps2pdf command from ghostscript to convert to PDF. (The Arch wiki has a good writeup on ps2pdf.)

The biggest problems with this are:

  1. It’s a lot of typing to get the conversion to happen (the minutia of which you won’t have memorized).
  2. It leaves you with both a PostScript and a PDF of the document(s), one of which is likely to get out of sync with the other, which may or may not be in sync with the actual schematic, etc.

To help with this, I use the script below. I drop a copy of it into the root of my KiCad projects and edit the OPTIONS as needed for the project. Then whenever I want PDFs of my schematics, I export PostScript from Eeschema and then click on this script in my file manager. Note that running this script will destroy any *.ps files in the directory—that’s by design.


# DESTRUCTIVELY convert all postscript files
# in working directory to PDF.
# Requires ghostscript.

# Mithat Konar 2013 []

OPTIONS="-dOptimize=true -sPAPERSIZE=11x17"

FILES=$(ls -1 *.ps)

for file in $FILES
  ps2pdf $OPTIONS $file && rm $file

I’ve not tried the script on any PostScript files other than those produced by Eeschema, but I’ve got no reason to think it won’t work on other PS files as well.

Custom six-channel DAC

the DAC's guts

Last week I finished delivery of a custom 6-channel DAC for mastering engineer Greg Reierson at Rare Form Mastering. It uses three stereo DAC cards I designed previously for Audio by Van Alstine, Inc. (currently used in their production DACs) and six custom dual-differential gain/filter cards. I designed the gain/filter cards to use an absolute minimum of active stages—something I have consistently found to help subjective performance.

Greg reports that the new DAC is dead silent and delivers noticeably better LF control than his previous setup. We hope to do some gain-stage device (that’s opaque-speak for “opamp”) comparisons down the road to see if things can be improved further. He will be using the new DAC for general monitoring and also to drive his newly acquired Neumann VMS 70 cutting lathe.

Stitching layers between copper zones in KiCad


Note: This is a 2011 repost from the now mostly defunct Biro Technology blog. I’m reposting it because it’s good information that belongs here. (P.S. Added it to the wiki.)

I’ve been working a bit with KiCad lately and have run into a problem in PCBnew with “stitching” (i.e., adding vias between) filled zones on top and bottom layers. This is something you typically do if you have flooded the unused spaces on both top and bottom of your board with copper and have connected the floods to ground or some other reference.

The KiCad FAQ outlines a process for doing this, and it works fine until you refill (i.e., re-pour) the zones–or the DRC refills them for you. When the zones are refilled, the vias you added for stitching become isolated from the zones and end up as little pads floating in space.

The problem and a workaround was discussed in a recent thread on the kicad-users mailing list. I wanted to summarize here the workaround in a slightly less terse way:

  1. Route the board and define your zones as you always have.
  2. Fill the zones as you always have.
  3. Select “Add tracks and vias” from the toolbar on the right.
  4. Click on an existing pad that’s connected to the zone’s net, drag the pointer a little bit to create a short track, then either (a) right-click and select “Place Via” or (b) type the ‘V’ shortcut.
  5. To add more stitching vias, continue to drag the pointer and type ‘V’ where you want to drop vias (or right-click and select “Place Via”).
  6. When you are done placing vias, hit the ‘End’ key on your keyboard (or right click and select “End Track”).

You can repeat this as many times as you want to create different clusters of stitches. When you refill zones, the vias will retain the connectivity information and work as expected.