Making the MC624 Remote (in Exhausting Detail)

I made something.

This thing is a hardwired desktop remote control unit made to interface with the Sound Skulptor MC624 stereo monitor controller.  The remote sends control commands via a serial interface to the MC624 (which performs all of the actual audio handling) and indicates the selected input, output, volume level, and other monitoring functions.

The Eye Socket MC624 Remote.

Designing and building this device was a quite complex and challenging process for me, with a number of peculiar problems to solve and new skills to learn.  The project developed sporadically over the course of seven months, from sketchy concept in February 2017 to finished piece in September.  Reflecting on this process I have decided to document it here.  My hope is that I have included enough detail to be useful to those who might be interested in building a similar device, but not to overwhelm those who are simply interested in the story.

This remote is not available as a product for sale, but all the technical details of my design, including the panel designs, part sources, wiring diagrams and open-source code, are shared freely on Github.  

Design:  Inception

For the unfamiliar, a monitor controller is a piece of studio equipment that allows the user to control what they are listening to, and how.  An array of audio sources are connected to the controller’s inputs, and the user selects one of them to listen.  That signal can be directed to any of several outputs, which are connected to different sets of monitor speakers (or, more accurately, to their amplifiers).  The level of the output signal is adjusted with an attenuation control – the all-important volume knob.  Other functions may allow the user to mute the output of one or both channels (left/right), to dim or reduce the output level by a pre-set amount (such as -15 dB), to sum the left and right channels to mono, and to invert polarity on one channel’s output.  These last two functions allow the engineer to test how the stereo image of their work will sound under adverse playback conditions.

The SoundSkulptor MC624.

There are many devices like this available from a range of manufacturers, with different configurations of channels, inputs, outputs and controls.  For a recent upgrade to my studio I chose the Sound Skulptor MC624, which comes as a DIY kit (or can be purchased fully assembled).  The MC624 is a stereo controller with a minimal signal path – all switching is done by relays, a passive resistor network controls volume, and a single buffer op-amp is the only active component in the audio path.  There aren’t any capacitors in the signal path, unless the builder opts to put DC filtering on the inputs or outputs (I didn’t need to).

The MC624 back panel.

The MC624 has six inputs and four speaker outputs, plus a metering output.  A very decent headphone amplifier is built in.  Setup options can be programmed via the front panel.  It’s a simple, thoughtful design, perfect for my needs.  Unusually, though, it does not include a dedicated remote – although it is designed, rather cleverly, to “learn” and be controlled by any infra-red wireless remote.  The IR control works well, and I used it that way at first – but I couldn’t resist the idea of a desktop remote.  In any studio the monitoring selections and listening volume are manipulated frequently, so having those controls at one’s fingertips, dedicated to their functions and clearly marked, is particularly helpful.  The question thus emerged:  Could I build my own?

In conversation with Sound Skulptor engineer Jean-Pierre Kuhn I learned that the MC624 was indeed designed with a provision for wired remote control – the same system of serial control that allows multiple MC624 units to be linked together for multi-channel surround systems (in which one master unit controls two or more slave units).  Jean-Pierre kindly provided me with the interface specifications and serial code table, and with that I knew my project was feasible.

The MC624 serial command table.

Design:  Objectives and Parameters

Well…I was pretty sure the project was feasible.  In fact there were quite a few things about it that I had no idea how to do.  But it was a compelling challenge, and I felt confident that I would be able to figure it out.  To begin, I established some basic objectives:

  • This is not intended as a product.  I will build exactly one, for my own use.  I am not interested in manufacturing, marketing or other commercial concerns.
  • I will build and program on the open source Arduino micro-controller platform.  This way I can experiment gradually, learn what I need to learn, and lean heavily on the work of others.  In turn I will share my code and other design details freely.
  • Build quality will be uncompromising.  I won’t agonize over economy of cost or time.
  • As the interface to my monitoring system, this will be the most-used piece of equipment in the studio.  I want the luxurious look and feel of first class audio equipment, with my own visual style preferences on full display.

Design:  Visual Inspiration

To me, visual appeal is an important quality in audio gear.  Even though we’re making audio (the audience doesn’t hear what the tools look like), that creative process can benefit tremendously from visual style and razzle-dazzle.  Since early childhood I have been drawn to control panels with lots of buttons, flashing lights, gauges, knobs and sliders.  (I suppose, if I hadn’t been so interested in music and sound, I might have made a good spaceship pilot.)  I particularly love the chunky controls and utilitarian simplicity of early military and science equipment, the Art Deco designs of 1930s radio and electronic test gear, the masses of buttons and indicators on early computers, and the spectacular and whimsical (if not always realistic) designs of fictional control panels in movies and television.

      

Some of these characteristics can be seen on recording equipment from the early- and mid-20th century, but they are seldom found on new gear (one notable exception being the designs of Shadow Hills Industries super-genius Peter Reardon).  My aim was to evoke the emotional essence of bygone technology and design, without being specifically authentic to any one era – combining different elements together into a piece that might have come from some alternate 20th-century reality.

Design:  Functionality

I began by outlining what controls the remote needed, and what they would actually do.  The particulars of each control type would be important in developing the code.  The MC624’s link interface and command table largely defined the function set:

Input (source):  A group of six buttons – only one at a time can be selected.  When one is pressed, its indicator lights, the one previously lit (if different) turns off, and the appropriate command byte is sent to the main unit.

Output (speaker):  A group of four buttons, with the same kind of function as the input buttons.  In fact, the input and output selections are both expressed to the main unit in the same byte, so the remote sends the appropriate byte for both whenever either is changed.

The behavior of input and output selections is latching, meaning the user presses a button and the selection “sticks” after the button is released.  They are also exclusive, meaning only one of each (input and output) is selected at a time.  (This is also known as “radio button” behavior.)  And one of each is always active – there is no “none” option for input or output.  So if, for example, input 4 is selected and the user presses the input 4 button again, nothing changes.

Functions:  Mute L, Mute R, Dim, Mono, and Invert R.  Unlike the input and output selectors, these five are independent, not exclusive – i.e., they can be on or off in any combination.  The function buttons latch and toggle – pressing a button once turns that function on, and pressing it again turns it off.  A byte is sent (expressing the status for all five functions) whenever one is pressed, and their indicators light accordingly.

Volume (attenuation):  A value is read from a rotary control, scaled and formatted into a command byte which is sent to the main unit whenever the value is changed.  A numeric display continuously shows the current value.

Storage:  The MC624’s input and output selections persist on power down/up, and the remote should work the same – so that when the system is powered up, the remote will correctly indicate the status of the main unit.  (The remote doesn’t receive status information from the main unit, because the serial connection is one-way only.)  To achieve this, when the selection is changed on the remote, a status byte is also written to non-volatile EEPROM onboard the Arduino.

Startup:  When the system is powered on, the remote runs a startup routine that flashes all the indicators and the numeric display, retrieves the input and output settings stored in EEPROM to light the appropriate indicators, reads and transmits the volume control value, and mutes the left and right outputs (to protect the speakers).

Design:  Technology

Buttons.

The choice of switches is crucial to the look and feel of the remote.  I shopped around at length to find pushbuttons I liked (that weren’t ridiculously expensive and/or sold by the hundred) and finally settled on these, from a Chinese seller on eBay – 12mm square, momentary-contact buttons with independently-powered 6V LED indicators, in various colors.

Arduino MEGA 2560.

To connect fifteen buttons with fifteen LEDs to the Arduino, I needed either a board with lots of digital I/O pins or some form of multiplexing.  To avoid the complexity of the latter I opted to build on the Arduino Mega 2560.

RS485 board.

The MC624 uses RS485 serial protocol to send or receive remote commands.  The Arduino can transmit serial messages, but it doesn’t natively use RS485.  For that I found this RS485 interface module.

Bourns pot.

I had some particular requirements for volume control.  The MC624 itself uses a continuous, incremental (relative) digital encoder to adjust volume and other system settings.  For the remote I wanted to use a conventional, non-stepped analog potentiometer with stops at either end of its range, and a large Bakelite pointer knob indicating absolute position.  The Arduino can read voltage to an analog input through a typical 10kΩ pot, yielding a value from 0 to 1024.  That value would need to be smoothed in software (to reduce noise) and scaled to the 64 single-dB attenuation steps on the MC624.  I used this Bourns high-torque pot to provide a smooth turn with some resistance, for a luxurious feel.

LED segment display.

The simple and obvious choice for a numeric volume indicator was the common LED segment display, and there are many varieties available – but I wanted to do something else.

A Nixie tube calculator.

A particularly striking component seen in some computing equipment from the 1960s and 70s is the cold-cathode display (aka Nixie) tube.  This inefficient, “obsolete” technology with its glowing numerals-in-glass has had a renaissance in recent years among electronics makers and retro-tech enthusiasts (especially for clocks).  I’ve long been fascinated with Nixie tubes, and as the concept for my project took shape it seemed I finally had an opportunity to use them…if I could figure out how.

IN-2 Nixie tubes.

Happily, I found among the vast Arduino developer community an interface designed specifically to drive Nixie tubes with an Arduino micro-controller:  the ArduiNIX shield.  The ArduiNIX converts the Arduino’s supply voltage to the 170V needed to drive Nixie tubes, and performs all the switching to run up to eight of them (with software multiplexing).  I bought a kit, and a supply of Soviet-made IN-2 tubes, and began building.

Build:  Prototyping

The version 1 prototype.

My first prototype had a simple wedge shape, with buttons wrapping around a central volume knob and two Nixie digits for volume.  To design the control panel I used proprietary CAD software from Front Panel Express, a company that takes user-created designs and executes all the custom milling, engraving and finishing.  My prototype enclosures were made simply using recycled cardboard and tape, and a printout of the panel on ordinary paper.

I had a lot to learn about Arduino coding, but having some programming experience in other languages I adapted to the Arduino environment (a C/C++ variant) easily enough.  I made good use of existing libraries and programming examples, along with the time-tested “change something and see what happens” method.

Version 1, mostly functional.

After much trial-and-error I had the functions working well, but there were a few issues with the form.  First, I had a problem with the angle of the panel.  To put the Nixie tubes at the best viewing angle, the whole panel needed to be very steep – 60 degrees – good for viewing but awkward to operate.  Second, the big volume knob was really too big.  And third, since I already had the hardware, I couldn’t resist the idea of adding two more Nixie tubes to display the input and output selections.  It would be gratuitous (as the buttons were already doing that job) but spectacular, if I could fit them into the layout.

Version 2.

So for version 2 I split the panel into two, with a shallower angle for the controls and a steeper one for the display tubes.  I rearranged the buttons around a similar, but smaller, old Bakelite knob and added the Nixie tubes for input and output.

I realized that the LED indicators were too bright, making a distracting glare in the corner of my eye when I was looking at the computer screen.  Current-limiting resistors would remedy that, with some experimentation to find the best value for each color.  I also wanted to make the entire piece smaller, and move a few things around.

Version 3.

Version 3 is where the final design came together.  I moved the speaker buttons to the right with the function buttons along the bottom, and changed some of the panel labels and other details.  The tubes for source and speaker are moved to the outside, corresponding to their buttons, and attenuation is in the middle above its control knob.  I also sloped the top of the enclosure downward, at 90 degrees to the upper panel.  The overall form is more compact, with just enough room for the internal electronics and wiring.

Along with the other panel details, I had been experimenting with some simple Art Deco embellishments inspired by radio and test equipment from the 1930s.  Those designers commonly used groups of three or four lines as a graphic detail (there must be a name for them).  Mine were merely ornamental at first, but here they also define the arrangement of controls – as they should.  Arriving at this seemingly simple layout took a lot of fiddling.  I agonized (for longer than I want to admit) over these three options for the upper panel before finally choosing one.  I still like all of them.

White buttons?

I also experimented briefly with white buttons in place of the blue.  I had to see what it would look like.  It’s not bad, but I went back to blue.

The remote’s electronics require three separate wired connections for power and interface:  9VDC to the Arduino, USB to the computer for programming, and RS485 to the MC624 itself.  I wanted to do all of this in one cable.

The cable assembly.

For a simple look consistent with the remote’s retro-industrial style, I used braided cloth-covered cable from Peluso (made for tube microphones) and these connectors from Binder to build a custom cable combining all three functions.  There’s one simple connector at the remote end, and the other end breaks out to the three connecting devices.

The Arduino IDE.

Throughout this process I was constantly revising the code.  As a newcomer to Arduino programming I was surprised to discover how much room there is for different approaches to any one task or process.  Like any other written language, code can be elegant or messy, graceful or clumsy, concise or wordy.  Each problem is a puzzle; the more challenging the puzzle, the more satisfying the solution.

Among the improvements I made were introducing more effective smoothing of the analog potentiometer values (courtesy of Damien Clarke), adding a subtle cross-fade effect to changing digits on the Nixie tubes, and optimizing some things I had done less efficiently before.  Although I have everything working perfectly well now, I suspect there are still things that could be written more efficiently, and it’s likely that more improvements will follow.  A huge advantage of building the remote on this platform is that I can adjust and upload new code at any time.

Build:  Enclosure

v3 – the final prototype.

At this point I was happy with the form factor, control layout, panel design, and functionality.  Although it was made out of cardboard, the remote was already in daily use in my studio.  For the final build I needed to have the real front panels produced, and I needed a proper enclosure.

Front Panel Designer.

I had made many revisions to the panel designs, adjusting different visual and technical details, taking great care to ensure the actual product would turn out as intended (especially because I had never done anything like this before).  By the time I finally sent the designs to Front Panel Express for production, I was up to version 29.  But the obsessive attention to detail paid off:  the results were perfect.

The enclosure plans.

I had always hoped to make the enclosure out of a nice hardwood, but I still hadn’t worked out how.  To build a wood enclosure in this shape, with the necessary precision, I lacked the skill and the proper tools.  But my dad, the brilliant Dave Blinman, has plenty of both.  I asked if he was willing to take on the project, and to my delight he agreed!  Together we worked out the specifics of wood type, dimensions and construction.  Dad made several recommendations that were crucial, helping to solve some construction problems I hadn’t figured out yet.

The enclosure.

I chose Bubinga, a fine African hardwood with a somewhat exotic appearance, and Dad went to work.  The result was astounding.  He carried out the construction with exquisite care and precision, giving the piece a luxurious look and feel that far surpassed my expectations.

I needed to drill holes in the enclosure for the front panel, rear connector and rubber feet screws – a job demanding such precision that it practically forced me to buy a drill press.  Which I did.

Finishing the enclosure.

After drilling, I sanded and finished the enclosure with a few applications of traditional boiled linseed oil, which deepened the color and grain perfectly.

The application and drying time took the better part of a week.  Then, at last, it was time for final assembly.

Build:  Assembly

Tube backplate and wiring harness.

Rear connector installed.

Most of the electronics work was already completed in prototyping.  I had fashioned a backplate for the Nixie tubes out of two layers of perfboard, with the tube sockets sandwiched between.  I considered having a custom circuit board made, with the tube sockets, resistors and connectors onboard – but my homemade version works well, and its crude appearance is hidden inside, so I’m still using it.

Tube assembly installed.

I made simple aluminum L-brackets to mount the tube assembly in the enclosure.  All of the positioning is adjustable, to allow for manufacturing variations in the tubes and ensure that they can be aligned exactly with the front panel.

Wiring the control panel.

I wired the control panel buttons and potentiometer, first with a common ground and then adding the individual LED resistors and wires for each switch and indicator.  (For the full wiring diagrams and other technical details, visit my project repository on Github.)

At last, both panels went into place and I connected everything to the Arduino and ArduiNIX shield for final testing – which, happily, was successful!

Electronics fitting into place.

The Arduino stack and RS485 interface are mounted to a board (not pictured) that fits into the bottom of the enclosure, held neatly in place by the bottom panel.

Build:  Conclusion

The completed MC624 Remote.

Fully assembled, the remote looks stunning.  Soft rubber feet mounted to the bottom panel float the unit just above the desktop surface while holding it firmly in place.  It is exceptionally solid and heavy (over two pounds) and deeply satisfying to operate.

Visually, the glowing Nixie tubes and blocky primary-colored buttons, subtle Art Deco panel engravings and Bakelite volume knob, and precise, elegant woodwork all combine into a striking piece, at once familiar and unique.  As a controller it is intuitive, responsive, and reliable – exactly what I wanted.

The completed MC624 Remote.

The feeling of taking this complex thing from dreamy speculation to a finished, working device is powerful.  When I began, using Nixie tubes was a vague fantasy, Arduino programming was a murky ocean of wonder and uncertainty, and industrial design and metalwork seemed out of reach somewhere in the domain of trained specialists.  Now the finished piece sits on my desk, not only serving its intended function perfectly but exemplifying the DIY process that yielded it – the problems solved, challenges overcome, skills learned, knowledge gained and shared.

With experience comes the confidence to travel further.  Although I am still a newcomer to this kind of work, I now feel a vast galaxy of possibilities is within my reach – and I’m already dreaming about the next project.

Special thanks and love to my dad, whose work on the wooden enclosure elevated this device to a height of beauty and quality I hadn’t imagined – and whose influence is visible in its every aspect.

Tweet about this on TwitterShare on FacebookShare on TumblrShare on RedditShare on Google+Email this to someone