Magic Eye Tube 6e5c

Magic Eye Tubes were used as RF-indicator tubes on radios from the 1930s until the end of the tube era and needle movement meters displaced them.

I love the glow of these tubes and want to use one as a rudimentary S-meter in my homebrew HF-transceiver. I purchased two Soviet 6e5c tubes from Ebay. I think both of them were used. I also bought two VU-meter PCBs from a Hong-Kong Ebay seller.

I could not find a schematic, but drew the circuit diagram based on the PCB on a piece of paper in order to understand the circuit. From my understanding it is a basic buffer audio amplifier followed by a DC coupled stage that rectifies the negative half cycle to provide the negative DC to drive the Magic Eye Tube.

Soldering the PCB was simple and I had all components in my junk box. The tube is mounted in a 8 pin PCB-mounted socket. There seems to be room for a LED beneath the tube. Nice if you want to pimp it up a notch or two. I do not want such modern nonsens in my old-school experiments, so I skipped that.

For the power supply I purchased a high-voltage supply from Ebay. Unfortunately, it does not seem to be able to provide enough current to drive the tube at any higher voltage than 180V, so it is a bit dim. I have to find an alternative solution. For the heater I used 6.3 V DC.


I used a signal generator to test the circuit. It was very satisfying to see the Magic Eye Tube perform its magic. The above video should convince you.

Future work include soldering up another tube and mounting them in a box together with my Nixie-tube display and some hefty dekatrons.

Homebrew SWR and power meter

First of all, this SWR meter in this article is not exactly homebrew, as I based the circuit on the schematic in the excellent book Arduino Projects of Amateur Radio. Although I bought the book and respect the copyright of the authors I will share my own schematic here. Why? First, the design in the book is not completely original and is based on similar designs from others. One example here.  Second, I changed a few things, removed some stuff,  and added some other things, to my own liking, so the design is not identical anymore.

The circuit is based on two AD8307 log amplifiers, which are connected to the forward and reflected ports on a directional coupler.  The AD8307 amplifiers gives a DC voltage of about 25mV/dB of the input signal, which is amplified using an opamp (LM324). The opamp also provides the reference voltage to the Arduino (AREF) to ensure that the full ranges of the A/D converters are used.

I used the fourth opamp in the quad LM324 to provide input voltage reading. That is why the PCB in the picture has two power jacks. One input and one output. That way I know the drive voltage for the radio. I primary plan to use this device for my Softrock.

I created the schematic and the board in Eagle, and submitted the gerbers to Elecrow. I received 10 PCBs after about 25 days.

The board is not much larger than a standard 20x4 LCD.

I choose to use an Arduino nano rather than populating a AVR328 on the board and messing with USB converters. I am glad I did. I did one mistake on the board however. The Arduino was not powered from the 5V rail. The problem was that it was an error on the Eagle footprint for the Arduino Nano. I just downloaded the footprint file uncritically from the Internet without checking it. Other than that, It was fine.

Another problem was that I got oscillations on the LM324 opamps connected to the AD8307. The oscillations were around 40KHz and about 400mVpp on top of the DC signal. Hence it was impossible to calibrate the device. The solution was to desolder the output capacitors on the LM324. I do not think they are really needed on a DC design.

This was my first SMT design, and I am fairly happy with the result. The SWR and the power measurements seems accurate. I used the Arduino software from the book, and modified it to include a larger display and some other things. As you may notice, there are no buttons on the device. Originally I planned to use a rotary encoder and a bunch of menus, but as they say in the Soldersmoke podcast, menus are for restaurants. I totally agree. Besides, programming all kinds of features to the device is totally insane. This is a simple SWR meter and thats it. 

The files are available here, should you be interested. Note that there is an error in the schematic. The Arduino is missing +5V, but it should be easy to fix.

Homebrew dummy load

I have created a simple 50 Ω dummy load to test transmitters. I also added a simple RF diode detector so I can measure the peak voltage, and calculate the power.

  

The dummy load consists of eight 100 Ω resistors rated at 2 W so the load should handle 16 W, at least for short periods. I constructed the dummy load using a combination of ugly construction and Manhattan style, by gluing pieces of PCB  (as isolation pads) on top of a ground plane PCB.  Then I soldered the components directly on the copper without drilling holes.

RF Probe

The RF probe part consist of a simple 1N4148 diode and a 0.01 uF ceramic capacitor. I only had a 50 V capacitor in my junk box, but it should be sufficient given that this is a 16 W dummy load and 16 W translates to 40 V peak.

I added female banana connectors, which connects to a multimeter. The power can be calculated by Ohms law by subtracting the forward voltage on the diode from the measured voltage, then multiply by 0.707 (to get RMS), then square the result and finally divide by 50 Ω. Some homebrewers add a voltage divider to their RF probes using a 4M7 resistor to get RMS voltage directly. I did not bother since I am sure the input impedances on my multimeters varies.

The calculations might seem a bit cumbersome, but I might print out a small lookup table and glue it to the box to have some ballpark figures. However, this is not a precision instrument. The forward voltage on the diode varies with load and can be somewhere between 0.4 and 0.7 V. I simply use 0.5 V in my measurements.

So far, the dummy load has been very convenient when testing my Softrock RXTX and its low pass filter,

Further reading

1. Jeelabs, Forward voltage drop on a diode
2. NXP, 1N4148 data sheet
3. N5ESE, Classic RF Probe

Softrock RXTX completed

After finishing up the receiver part of my Softrock Ensemble RXTX SDR transceiver with great success, I got really motivated to get the transmitter going. The last weeks I have followed AB4UG's progress building his own RXTX with great interest, and I got even more motivated to finish my own kit when I saw that he got the last component soldered on his RXTX.

Soldering the last component on the RXTX

Building the TX part was fairly easy after having built the RX part. The first thing after melting the last piece of solder on the board was to make a 50 ohm dummy load using a few resistors, and then to measure the output power with my scope. After that, I balanced the I/Q signals by playing with the TX image rejection settings in WSPR and by watching the transmitted signal on a RTL-SDR receiver. The RTL-SDR operated in a software direct sampling mode to make it work on the 20m band. This setup is not the best tool for this calibration task, but I think I came pretty close in my effort. I might check it up more thoroughly use a spectrum analyzer later.

RXTX is running WSPR

WSPR is an excellent choice for testing out a freshly built transceiver since it gives immediate feedback through Internet if anyone out there receives my signals. After a bit of fiddling, I got the RX mode running directly on I/Q in WSPR, and prayed to the radio gods that the TX would work as well. After verifying that the transmitter did "something" when connected to WSPR (it went hot), I left the softrock running for 24h with about 1W output. Then I just hoped that the black suited government frequency authorities would not kick down my door to revoke my amateur licence due to RF harmonics or for causing QRM on the image frequency.

Both RX and TX is now working in I/Q mode

Luckily the frequency authorities have not been kicking down my door (yet). On the contrary, during one night of operation I have gotten WSPR reports that my signals have reached most of Europe and even across the pond to America!

I can enjoy my working transceiver from my iPhone

I am truly amazed that my 1W transmitter (which I bravely soldered myself) can reach more than 7000 km. Notice that my "antenna" is just an indoor wire dipole (at about 5m length).

If you are listening on 20m and observe that my Softrock emits energy in the wrong parts of the frequency spectrum, please be kind to me. Please. I am a fresh amateur with very limited RF self esteem.

Summary of the build experience

I followed the excellent build guide of WB5RVZ step by step and it was really helpful. The most challenging part of the build was in fact soldering the through hole components on the awfully small soldering pads on the PCB. The SMT parts were mostly SOICs and 1205, which were easy. The Si570 (QFN) were the most challenging. I measured every resistor before soldering and took great care not to make any mistakes along the way. All in all, it was really an enjoyable build and the entire process building the transceiver took about 10-12 hours in total. The only mistake I did was to solder an opamp in the wrong orientation, but that was easy to fix.

Future work

The next step is to test out other WSJT digital modes such as JT65 and JT9 and to make some real QSOs. The goal is to make the Softrock operate stand alone on my Raspberry Pi2. 

DIYcrap audio mixer #3. FV-1 Reverb

This is part 3 of "building an audio mixer with effects". For part 1 go here, and for part 2, go here.

The mixer is working fine, and already has got two PT2399 circuits for delay. But now it is time to add some reverb. For reverb I decided to use an FV-1 based design. Experimental Noize has some nice small boards built around this chip, preprogrammed for different purposes. I decided to go for the SKRM-C8-R02 Mono-In/Stereo Out reverb and delay module.


I wanted to use a rotary switch to select between the different programs. The SKRM data sheet proposes to use a 74HC148 8 to 3 Line Priority Encoder for this purpose. Hence, there is a need for a small PCB to mount the SKRM and the 74HC148 (in addition to some additional components). Although I have used KiCad and OSH Park for PCB production previously, I wanted to test Fritzing for this small project.

I drew a quick diagram in Fritzing, swithced to PCB-view and the auto-router took care of the rest (at least most of it).

After a about ten days the card arrived in my mailbox.

The board came out quite nicely. Although I am very satisfied with the result, I do not think I will use Fritzing for my next project. OSH Park and other alternatives are way cheaper, and I think the Fritzing software is a bit limited compared to Eagle or KiCad (and even if the Fritzing-software is very simple to use, Eagle and KiCad are not that difficult to learn). The files are available at the Fritzing-site in case you are interested.

It took about 10 minutes to add the few components :-). It is only a 74HC148, a capacitor and a pull up resistor network.

Then I slammed the SKRM on top of it, soldered the connectors, and started jamming with some heavy reverb. But wait, I forgot one thing, namely to securely mount the PCB inside the mixer. A simple solution is to screw standoffs to the front panel, but the screws would interfere with the front panel design. I could also glue the standoffs to the front panel, but I just hate to glue things together when there is a slight chance that I might want to dismantle it later.

Hence, I created a plate to screw the PCB standoffs to, that is fastened with the rotary switch. It is designed in OpenSCAD and 3D-printed.

The above picture show how it looks like inside the mixer. Notice that the plate (in pink) is fastened together with the rotary switch.

The above picture show how the mixer looks like inside. The SKRM is driven by a LM7805 which is connected to the +12V rail (the blue heatsink can be seen on the bottom part of the picture). The circuit draws about 170mA, even if the data sheet states it should be less than 75mA. The reason? I do not know.

DIYcrap mixer. Now with reverb.

Building an enclosure for Mutable Instruments Shruthi-1

About a year ago I ordered a Shruthi-1 PCB and a Four Pole Mission PCB from Mutable instruments. After sourcing the components, it was a quick and enjoyable build. The synth has, however, been sitting in my drawer for a long time waiting for an enclosure.

First, I thought of buying the metal enclosure from Mutable Instruments. Besides the fact that the metal enclosure costs ¢55 (not a bad price, but still), I had, due to financial reasons, used different buttons than those recommended my Mutable Instruments. Since I had no intention to change those, I had to make my own enclosure.


Before bragging about my design I have to inform you that there is an excellent downloadable enclosure out on Thingiverse:284637. I tried it, but I just could not get it to print nice on my small RepRap Huxley.

I used OpenSCAD since it is Open Source and pretty nerdy. The box is pretty simple (and boxy), but takes only a couple of hours to print and consists of only three parts.

I created small cylinders for the LEDs. In this way they are highly visible on the front panel although the PCB is about 10mm below the panel. The cylinders also ensures that there is no light leakage from one LED opening to the next.

The final case looks ok. However, the Shruthi is not the easiest synth to use, at least when none of the buttons are labeled in any way. Therefore, I waned to create a panel with labels on.

Using the command "projection(cut=false)", the 3D drawing of the front panel can be converted to 2D. Then it is possible to export a DXF-file which can be imported in Inkscape. I learned this technique from this blog.

Once imported in Inkscape, I can create some text and stuff on the front panel. I used the same approach as I did on my mixer, and printed the front panel on some piece of colored thick paper.

Before laminating the paper, I cut out the opening for the display with an exacto knife and punched 3mm holes for the LEDs with a drill bit.

I had to extend the buttons with some Sugru to make the hight appropriate for the front panel. Looks a bit strange, but it works surprisingly good.

This is the final unit. You can download the design files on thingiverse if you like, and hack the heck out of it. The OpenSCAD-file is parametrized and it should be fairly easy to alter the design for whatever buttons you might have.


Here goes some additional pictures.

The front panel is secured with the nuts on the five potmeters.

The back plate is secured with the plastic nuts on the audio jacks.

DIYcrap audio mixer #2

This is part 2 of "building an audio mixer with effects". For part 1, go here.

The mixer is coming along quite nicely. Thanks to the excellent documentation on the Music From Outer Space web site and the professional quality on the PCBs, I had no problem soldering the four boards together.

The DIYcrap audio mixer

The picture above shows how the mixer looks. The different features of the mixer will be explained as we go. First, lets take a look into the assembly of the mixer.

Testing how the jack plugs and the knobs fit the front panel layout

As explained in part 1, I created the layout in Inkscape. I printed out a test on normal paper, just to check if all the knobs and plugs fitted nicely.

Running the paper through the laminator

After a few minor errors had been sorted out, I printed out the overlay on a piece of orange paper (I wanted the mixer to look a bit vintage and a bit seventees), and laminated it. This is the method proposed by MFOS and is by far the most economical approach to making synth front panels.

The panel is glued to the aluminum Bud-box

After the front panel was sorted out, it was time to fit the PCBs.

The PCBs

The PCBs are mounted on the back-plate of the Bud-box. From left to right in the above picture: Power supply, MFOS auto panner, two MFOS Echo FXXX (on top of each other), and MFOS panning mixer.

MFOS auto panner

Two stacked MFOS Echo modules

The MFOS panning mixer

All the MFOS-components are now mounted in the mixer cabinet and works flawlessly. The stuff that remains are, the SKRM FV1 reverb unit, a highpass filter, and a distortion unit. 

Testing the mixer with a function generator and oscilloscope

Thats it for now. The next part will (probably) cover installment of the the SKRM FV-1 module i purchased from Experimental Noize.

DIYcrap audio mixer #1

Introduction

During the last year I have built four synthesizers: a MFOS Noise Toaster, a x0xb0x, a Shruthi, and a Sonic Potions LXR drum machine. Hence, now I have an urgent need for an audio-mixer, and I have decided to build one, DIYcrap-style.

Modules

The mixer is based on the MFOS Stereo Panning Mixer. This circuit board uses TL071 and TL072 opamps and gives four mono input channels each with panning two effect send loops. In addition there are two stereo inputs, a headphone amplifier and stereo out to drive an external amplifier or recording unit.

I also need some built-in effects. The first effect is the MFOS ECHO FXXX. This is a PT2399-based delay module, and I am going to use two of these. Hence, they can be used in parallel (for awesome stereo effects), in serial (for super-long delays), or individually on two different mono-sources.

The second must-have effect is Reverb. I will use the SKRM-C8-R02 Reverb/Delay from

www.experimentalnoize.com. This unit is based on the Spin Semiconductor FV-1 and comes preprogrammed with a few stereo reverb and delay effects. With some additional circuitry it should fit nicely with the stereo mixer.

The last effect I am going to add is distortion (or fuzz). I have yet to create this module but i might try out the MFOS fuzz module to begin with.  The fourth module is also from MFOS and is a Stereo Auto Panner. Hopefully, this unit will provide some cool effects. Lastly, since delay and reverb does not fit nicely with low frequencies, I am going to add a variable high pass filter for the effect out part of the mixer. I might give this variable 20-200Hz filter a try.

Panel

One of the biggest challenges with the mixer is to create the front panel. Inspired by the latest Soundlab MkII from MFOS I decided to use the BUD-box AC-423. It is a 17x7 inch box in aluminium.

The status now is that I have soldered most of the boards and I have created the first version of the front panel in Inkscape.

First prototype of the layout (some text is missing)

The design is inspired by other MOTM-style synth-panels, like this one.

I also got useful tips about creating front panels in Inkscape here. Schaeffer is a popular choice for manufacturing the front panel. A more DIY-ish solution is to use LazerTran. However, I will probably just laminate an A3 paper and glue it to the AC-423 in the first version.

This project is still work-in-progress, and I will use this blog as my build log and as a place-holder for all the links I collect. 

Wordclock based on Arduino Yun

Introduction

This year, as every year, I did not have the faintest idea what to give my brother to his birthday, I decided, quite boldly, to build a birthday present with my bare hands. I figured out that everybody needs a clock, and that building a WordClock would be a funny challenge for myself.

The purpose of a WordClock is to present the time of the day using letters instead of numbers. I believe that the idea stems from the ClockTwo from Biegert & Funk (http://www.qlocktwo.com).
There are also other versions available for purchase (for example dougswordclocks.com.) as well as a myriad of DIY-designs. For example, this one, this one and this one, all on Instructables.

My DIY WordClock

Although the DIY-designs are fine, they are certainly not as sexy as the original ClockTwo, (and neither is mine). My design differs from the other alternatives (at least the ones I have found) in the following ways:

1. It presents the time in Norwegian
2. It has the possibility to show minute-precision time using the letters.
3. The time sets itself automatically using NTP (including daylight savings time).
4. It has a web-interface, so the user can use his smart-phone to adjust some clock settings.
5. It has a light sensor so the intensity of the LEDs can be automatically adjusted to the light in the room. (I know, other clocks has this as well)

To accommodate automatic adjustable time, I based the clock on the Arduino Yun, which besides being a standard Arduino with an Atmel AVR, runs Linux on a separate processor and can connect to WiFi and the Internet. The parts needed for this build is:

• Arduino Yun ($75 at Adafruit)
• 100 RGB LED-strips ($29.95 for 32 (1m) at Adafruit)
• A light-sensitive resistor (negligible cost)
• A resistor to match the above as a voltage divider.
• A micro USB connector
• A 2A 5V powersupply
• A acrylic front plate
• A frame, or something to hold the electronics and the acrylic front 

As the astute reader will notice, this is not the cheapest of the builds (although cheaper than the ClockTwo). However, thanks to the RGB-led strips it is relatively easy to build, compared to soldering and mounting 100 LEDs, and it also provides the unique ability to address every LED individually, and control their color.

The build

The first I did was to connect the light strip to the Arduino to check that all LEDs worked. All the strip needs is 5V, GND and two pins on the arduino.

The LED-strip connected to the Arduino

After verifying that the strip worked with some code provided from adafruit, I divided the strip in ten sections of ten LEDs, glued them to a 35cm x 35cm plate and soldered them together in a back-and-forth pattern.

The 100 LEDs glued to a plate, showing off with a rainbow pattern.

Since all the letters must be able to light individually, we do not want the light from one letter influence the neighbor letters. Hence some sort of frame must be built around each LED. I created a simple 2x4 design in OpenSCAD and let my 3D-printer do the job. Unfortunately, I only had black PLA, and since white is preferred to increase reflection from the LED, I spray-painted the frames. The result is shown below.

3D-printed frames fixed to the backplate with sugru.

The complete grid layout consists of ten 2x4 frames and five 2x2 frames. Obviously, I could have printed a 10x10 frame to cover the entire clock but that would have required a 3D-printer with approximately 35x35cm build areal.

The light sensor

To be able to fit the light sensor, a custom 2x2 frame was printed. On the top you can see the IKEA-frame which holds everything.

The 100 LEDs now have one little compartment each

With all the small 3D-printed frames glued to the back-plate with Sugru, it was time to figure out  a way to create the front-plate. This was by far the most difficult part of the project.

Front plate made in acrylic

The front plate is a 40x40cm acrylic photo print from http://www.idekor.no/. I made the lettering layout using a monospace font in inkscape, converted it to pdf, and then png, uploaded it to the online photo-service and hoped for the best. Frankly, even if the letters and the spacing between them was excellent, the result was a disaster, since the black was not entirely black. It was more grayish, and partly transparent.

Modifying the acrylic plate with some transparent plastic printouts

Since the sole purpose of the acrylic print was to isolate letters from background, I had to modify the acrylic by adding two layers of transparent plastic printed with the same pattern. Obviously I could have printed a new acrylic plate (maybe using a different online service), but sine I had already spent a small fortune on this one, and I was running out of time (this was a birthday present remember) I had to deal with what I had. To diffuse the light i used a layer of greaseproof paper.

The back of the clock with the nice IKEA painting

In the above picture you can see the back of the clock with 5V power at the bottom (white USB-cable taken from a Kindle), four wires to the LED-strip (top left) and two wires to the light sensor. The wires are connected to a custom Arduino-shield, which also powers the Yun. I used the original IKEA-picture since it was sturdy and perfectly fits the frame.

Old clock and new clock

I wondered for a while on how to fasten the acrylic front plate to the wooden frame. First I planned to drill holes in the acrylic plate and screw it using 75mm M3 bolts. Then, for some reason I read about fractured acrylic and did not dare to drill holes in my precious plate. Hence I decided to glue it in place. Using glue also had the benefit of allowing micro adjustment of the position of the acrylic plate over the 10x10 frame.

Well, the decision to use glue turned out to be fatal. Somehow I forgot that the acrylic plate was semi-transparent even in the black areas, and some of the glue can be shown from the front side of the clock. Typical DIYcrap mistake. Other than that, it was excellent.

How it works

Since this was a birthday present, I wanted an individual touch of the clock. Hence, while the clock boots, it shows the name of the owner of the clock. The letters in the name is used to indicate the progress in booting as well as outputting some status information. Even if the clock will probably boot very seldom (if ever) it is great for debugging purposes, so lets follow the process.

First the clock says that Arduino is working by showing a green "A". You may say it is sort of superfluous, since the LED-strip will not work without the AVR, but thats missing the point (and the fun).

After about a minute, Linux is running, (L is green). We can also see that we got Wireless connection (signal strength 5/7, since L,F,O,R,D is green), and we got an IP-address from a DHCP server (D is green).

Now, we have a connection to the internet (I is green). A connection to the Internet is simply verified by pinging google.com. If this address somehow dies (if google goes bankrupt), the letter "I" turns blue, but the clock will still operate.

Now, the letter "N" shows that we have received the time from a minimum number of four NTP-servers and we therefore believe that the time is set correctly in Linux.

At last, the letter "E" indicates the ambient light in the room as perceived by the light sensor at boot time. Red indicates low light, green indicates medium, while blue (as in the picture) means that there is a lot of (sun)light in the room, and the LEDs are set to maximum intensity for the time being.  (The intensity-adjustment is of course performed continuously as the clock operates, regardless of the amount of light during boot time). 

Using a simple web-interface, the user can select some additional features using his smartphone. A rainbow pattern for example, is always supercool. Since the Yun uses Bonjour and UPnP and all that stuff, the web-page can easily be found on the local WiFi using the arduino.local address.

A standard WordClock can only show the time in five-minute intervals. An additional feature that can be enabled using the web-interface is the ability to show minutes. This is performed by letting the letters K,L,O,K presented a different color. In the above picture, the three letters K,L and O means that we should add three minutes to the time showed. Thus the time is not five minutes to (fem på) "something", but rather two minutes to "something".

The verdict

I am quite satisfied with the build. Obviously, I did not choose the cheapest method, but the combination of the RGB LED strip and the Arduino Yun turned out to be a very fun and rewarding combination. I am certainly going to use the Yun in other projects as well. Had it only been a bit more affordable.

Another downside with the Yun is the limited codespace on the 32U4 microprocessor. With the bridge library, the LED-strip library and all the other stuff I almost hit the ceiling in code space. I even had to omit some super cool features that simply did not fit the 32Kb space on the controller.

Update! Download code

You can now download the code here