One of many nice joys of Hackaday is the genuinely weird requests we generally get above the tip line. Concrete instance: [DC Darsen] wrote with a damaged organ from the Seventies that wanted a brand new increased octave generator, and puzzled if we might assist. He had discovered a sophisticated however promising circuit on-line and puzzled if there was something easier. I replied, “I ought to be capable of do that with only one Arduino” and began to show myself lifeless unsuitable very quickly.

We move the accountability on to you, pricey Hackaday reader. are you able to assist [DC Darsen] to restore your organ with a minimal of expense and problem? All we have now to do is concurrently produce twelve, or perhaps 13, sq. waves of various heights.

Prime-Octave What?

Pipe organs produce sound by vibrating the air in extraordinarily giant tubes, one for every peak. Then got here the Hammond organ, which from 1935 to the mid-Seventies produced sound by rotating metallic discs with periodic cutouts within the presence of an digital microphone. A Hammond remains to be not a small machine, however it was positively compact in comparison with the pipe organ. Within the Eighties, all this era of sound may very well be contained in a devoted built-in circuit, ending the period of giants. (A minimum of for client devices: an actual pipe organ in a big house is all the time a pleasure to listen to in individual.)

However for a quick time frame between the Phonetic Wheel and the VLSI eras, there was a decade of home organs that had been designed with the available surprise expertise of that period, discrete logic built-in circuits. Particularly, these designs reap the benefits of the power of a flip-flop to take an enter frequency and divide it by two simply and inexpensively. Dividing a frequency by two lowers its perceived pitch by an octave, which meant that, when you might precisely generate a pitch for every of the twelve tones within the scale, you can use toggles and divide to cowl the complete vary. keyboard.

Reference Pitch Chip

Offering an correct set of twelve benchmark heights is the job of the Prime-Octave Generator (TOG) chip, an element that’s now not manufactured. However what if you wish to restore a Seventies organ that used it? You may be capable of order costly spare components, however the place’s the enjoyable?

Nearly all TOG took an enter frequency derived from a 2 MHz crystal oscillator circuit and offered twelve or 13 sq. waves of the right steps by dividing that enter frequency by elements from 239 to 478. If we had been to implement this in silicon, we might construct twelve 9-bit counters, all pushed by the identical 2 MHz grasp clock, and have them reset when the right counts have been reached. This ought to be simple to duplicate in firmware on an Arduino, proper?

Non-microcontroller options

The very best “C” on a piano is at 4,186.01Hz, which suggests we must toggle a pin roughly each 1,911 cycles for an ATmega Arduino AVR clocked at 16MHz. One step can be simple. This may counsel that you can naively implement it in software program, holding monitor of twelve counter variables and looping check to see if every must be reset.

whereas (1) {
    C7_TOGGLE;
        for (unstable uint8_t i=0; i<12; i++){
        if (counts[i] > tops[i]){
            counts[i]=0;
        }
        ++counts[i];
    }
}

However that does not match. For those who implement it this manner, the time between counts is simply too lengthy, and you’ll’t set any of the pitches exactly sufficient to be musically helpful. The above loop is round 20kHz, which is nowhere close to quick sufficient, and all of the pitches are out of tune.

Another strategy can be to let a {hardware} timer run freely, configure a timer variable for every oscillator, and toggle every oscillator when its particular person time is reached, then replace the GPIO pins.

However as a result of cut up oscillators function at totally different frequencies, even with simply two such oscillators, they’ll regularly come out and in. Ultimately, two transitions will probably be so near overlapping that going by the loop takes too lengthy to keep up them each, and one will reset late. With twelve oscillators operating, the outcome to shiver is audible, and it sounds horrible.

These considerations, and the will to take away the toggle dividers, are what drove Tom [Electric Druid] Wiltshire to construct your TOG with twelve PICs, one for every word on the size. Nevertheless, to work collectively they should run on the identical clock grasp, and Tom stories points with the PLL he was utilizing as clock grasp. I’ve beauty considerations with utilizing twelve PICs, though I suppose it is no worse than utilizing twelve synchronous counting built-in circuits for octave divisions.

Most microcontrollers have a built-in {hardware} timer circuit that may do precisely what we’d like, however twelve unbiased timers push it. An ATmega-powered Arduino has three {hardware} timers, and one is tied to the Arduino firmware. If you’re prepared to surrender millis(), you’ll be able to implement three of those oscillators in {hardware} and presumably run a fourth on the processor. You solely want three Arduinos for a full octave. We might get someplace.

Exaggerated, however believable

Some extra refined microcontrollers have twelve or extra {hardware} timers. I regarded round and located that the excessive density STM32F407 playing cards, obtainable for not an excessive amount of regular sources, have twelve 16-bit timers. I do not know if all of them can be found or usable on the similar time. Nonetheless, the all-hardware strategy has the benefit of stable timing, and the 16-bit subject decision is an enchancment over old-school TOGs. However throwing in a high-end microcontroller to work simply to go away the 168 MHz processor fully idle looks as if a waste one way or the other.

A TOG is definitely an ideal software for an FPGA. You possibly can implement the counter division design of the unique ICs pretty faithfully, and every of the FPGA and FPGA subcircuits work independently and really in parallel. Implementing the flip-flops for splitting would even be fairly simple, and so long as the FPGA has 88 free output pins, you’ll be able to generate all of the steps you need in a single piece of silicon. That might be kinda good.

Your flip

My intuition is that the FPGA resolution is the most effective, though it is not going to be appropriate for DIY for almost all of organ restore fanatics. Everyone seems to be aware of Arduino, however the timing of three or 4 of them appears to be an issue. The high-end microcontroller resolution ought to work, however appears pointless.

What are we lacking? The place’s the good hack that can enable twelve unbiased timers to run in software program on a single Arduino AVR? Only for psychological train, we’re actually excited by listening to practical microcontroller options. However perhaps you have got a secret trick to holding a dozen 555 timers tuned in? (We’ll imagine it once we hear it!) Does anybody wish to present us how easy the FPGA resolution may very well be? How would you implement a TOG?