The Kollsman Electrical Tachometer Indicator

On this submit, I check out a classic Kollsman plane electrical tachometer indicator. I begin by disassembling the tachometer to find out the way it works then construct up a variable-frequency energy provide to energy and take a look at the indicator. As soon as the facility provide and indicator are working, I measure the pace of the motor contained in the indicator to find out the variety of poles on the motor. Lastly, I repurpose this indicator as a singular CPU efficiency meter.

Outdoors Look

Once I bought the tachometer, I actually had no concept what I used to be getting aside from that it had {an electrical} interface moderately than a mechanical versatile shaft interface and it regarded cool.

On the entrance of the unit are two dials. The bigger dial signifies the tens digit of the % of most RPM and the smaller inset dial signifies those digits. The 2 dials are added collectively to get the full %. The bigger dial purple traces at 105% and goes all the best way as much as 120%.

On the rear is a receptacle with seven pin contacts and a nameplate. The nameplate lists the producer, mannequin quantity, serial quantity, and scale of the indicator. The dimensions is listed as “INDICATES 100% AT 4200 RPM GEN. SPEED.” The dimensions offers somewhat bit of data however nonetheless doesn’t convey how the pace of the engine is transmitted to the indicator. Possibly taking it aside would give me a greater concept of the way it works.

Disassembly

Eradicating the 2 screws on the rear of the unit allowed the principle physique of the instrument to be slid out from its case. This didn’t reveal many secrets and techniques however it did permit for inspecting the dials and gears on the entrance of the indicator.

Pushing on the massive needle confirmed that it was linked on to the massive gear instantly behind the face of the indicator through a small shaft. It additionally brought on the small needle to spin in a short time. Releasing the needle brought on each the massive needle and small needle to spring again to zero. Wanting carefully there’s a hairspring behind the massive gear close to the face of the instrument. This hairspring is linked to the identical shaft as the massive gear and principal needle and it’s this hairspring that causes the needles to spring again to zero when no power is utilized to the shaft.

Wanting on the proper hand aspect of the entrance finish of the indicator reveals that the massive gear turns a bunch of smaller gears which are linked to the smaller needle. This causes the smaller needle to spin at a a lot sooner fee than the principle giant needle.

The following step was to separate the principle physique from the rear panel and indicator dials then disassemble the principle physique. Eradicating the rear panel from the principle physique revealed yellow, black, and blue wires going into the physique and two wires used for illumination. Eradicating the rear panel additionally allowed entry to a few small screws that when eliminated permitted the principle physique to be disassembled.

Disassembling the principle physique confirmed it housed a three-phase synchronous motor. The rotor spins on bearings positioned on the entrance and rear of the principle physique and suits contained in the stator. The yellow, black, and blue wires are linked on to the stator windings. The stator windings look to be divided into 12 teams so that is seemingly a four-pole motor. There are not any brushes within the motor or windings on the rotor.

The clearances between the rotor and stator are very tight. It took a number of tries to get the principle physique reassembled the place the rotor would spin freely contained in the stator however I did finally get it again collectively and dealing once more.

The magic occurs on the finish of the principle physique close to the entrance face of the indicator. On this finish of the principle physique are a big spherical magnet that spins and is hooked up to the rotor. Across the magnet is an iron protect that spins with the magnet.

On the indicator aspect is a copper cup. The copper cup suits into the hole between the magnet and protect however doesn’t make bodily contact with the magnet or protect. The copper cup is linked to the identical shaft that’s linked to the hairspring, giant gear, and huge needle on the entrance of the unit.

Because the magnet and protect spin however don’t make contact with the copper cup and copper is a nonferrous metallic, some mechanism is required to show the spinning of the magnet right into a power on the cup to show the shaft to show the needles. Time to do a little analysis!

Magnetic Drag Cup Tachometers

After doing a little bit of trying round, I realized that that is referred to as a magnetic drag cup tachometer. The rotating magnet induces Eddy currents within the copper cup which causes the copper cup to rotate and apply a power to the shaft that counteracts the power utilized by the hairspring. The shaft rotates and the pointer strikes to the purpose the place the steadiness of the 2 forces is equal. The sooner the magnet spins, the larger the currents induced within the copper cup, the larger the power produced on the shaft to counteract the hairspring, and the larger the deflection of the pointer away from 0%.

The most effective illustration of the magnetic drag cup tachometer is on the Kollsman poster proven above from the Smithsonian Institution’s National Air and Space Museum collection. This poster depicts a magnetic drag cup tachometer linked to the engine by means of the usage of a versatile rotating shaft. The reason reads:

The versatile shaft for driving the tachometer goes on drive shaft D. Clutch E is mounted to shaft D and, when shaft D is turned within the path of the decrease arrow, one of many clutch arms is pushed towards the button on gear A, turning gear A with shaft D, driving gear B within the path of the arrow on gear B, and driving gear C within the path of the arrow on the shaft below gear C.

When shaft D is turned within the path of the higher arrow, the opposite of the clutch arms is pushed towards the button (not seen) on the below aspect of the gear, turning gear F with shaft D. Gear C is then turned by gear F within the path of the arrow.

That’s, shaft D could also be turned to the fitting or to the left, however gear C is always turned in a single path, which is to the fitting as seen from the face of the instrument.

The magnet M is turned by gear C inside the protect S. Drum G is supported on the decrease finish of employees H, between the magnet M and the protect S.

Hairspring J and kit Okay are mounted on employees H, on the higher finish of which is the lengthy hand L.

The place of the drum G and of the hand L (the 2 components being on the identical employees) is managed by the hairspring J, the drum being turned by the pull of the magnet until the power of the magnet is the same as the power of the hairspring.

The core functioning of the magnetic tachometer on this poster is similar to my tachometer. The primary distinction is that my tachometer has a synchronous AC motor that turns shaft C as a substitute of a versatile rotating shaft. The opposite main distinction is that the face of my tachometer has two dials to symbolize the tens and items moderately than a pair of concentric pointers.

Electrical Coupling Utilizing AC Synchronous Machines

Within the drag cup tachometer on the Kollsman poster, the pace of the engine is conveyed from the engine to the tachometer via a versatile rotating shaft. In my tachometer, the pace of the engine is conveyed from the engine to the tachometer via a three-phase AC generator, a three-phase AC sign transmitted over three electrical conductors, and a three-phase synchronous AC motor as proven within the diagram above.

The engine drive shaft is coupled to a three-phase AC generator. The generator produces a three-phase AC output whose frequency is proportional to the rotational pace of the engine drive shaft. Within the case of a two-pole AC generator spinning at 4200 RPM, the output frequency will probably be 70 Hz. If the identical generator is spinning at half that pace, the frequency will probably be halved to 35 Hz. If the generator is stopped, no voltage will probably be output.

Wires join the tachometer generator to the tachometer indicator. Contained in the tachometer indicator, the three-phase AC sign from the generator turns a three-phase AC synchronous motor. The pace of the motor will probably be proportional to and synchronous to the enter frequency. If the synchronous motor additionally has two poles, the motor will spin at the very same pace because the two-pole generator.

In different phrases, a 4200 RPM drive shaft will produce a 70 Hz sign on the output of a two-pole generator and a 70 Hz sign on the enter to a two-pole motor will trigger the motor’s shaft to rotate at 4200 RPM. If the drive shaft is slowed to 2100 RPM, the generator output is diminished to 35 Hz and the motor’s shaft’s pace may also be diminished to 2100 RPM. On this method, the pace of the drive shaft is conveyed from the engine to the tachometer indicator.

The motor’s shaft spins a everlasting magnet drum and iron protect. A copper cup is positioned across the drum. Because the drum rotates, it induces Eddy currents within the copper cup. The copper cup turns into magnetic and exerts a power on the shaft connecting it to the hairspring and indicator pointer. The upper the pace of the drum, the larger the induced currents and the larger the power utilized to the pointer’s shaft.

The needle will then transfer to the purpose the place the power utilized by the copper cup is the same as the counteracting power utilized by the hairspring. This causes the pointer to maneuver over an angle in proportion to the frequency of the AC sign on the enter of the tachometer indicator which can also be proportional to the pace of the engine drive shaft on the tachometer generator.

One other clarification of this method is on pages 4 to 7 of chapter 6 of the Small Fuel Turbine Engines Handbook by Ian F Bennett at gasturbineworld.co.uk. Ian additionally notes that many of those gauges point out 100% when pushed by a 4200 RPM two-pole generator which corresponds to a 70 Hz AC sign. Hmm, that’s precisely the size talked about on the nameplate on my tachometer.

The three-Section Variable-Frequency AC Energy Provide

Energy Provide Necessities

After disassembling this indicator, placing it again collectively, and researching the way it works, I made a decision it was time to get it operating once more! I don’t have a jet engine or tachometer generator so I figured the subsequent smartest thing was to construct a three-phase AC energy provide. I got here up with the next record of necessities:

• Repeatedly variable frequency from DC to 120% of 70 Hz (84 Hz).
• An adjustable voltage output. I don’t know what voltage the motor is designed to run from.
• Capable of provide a number of 10’s of mA of present per part. I don’t know how a lot present the motor pulls.

Thankfully, I already had a small board able to producing a three-phase AC sign. The voltage is adjustable from 0 to 7.25 V_AC and it’s able to supplying a number of 10’s of mA of present per part. This board could be sufficient to strive to determine the unknowns within the record of necessities above.

Energy Provide Schematic

This can be a three-phase model of the single-phase AC energy provide used on my synchro-to-digital converter project. The variety of channels has been elevated from one to a few and the Pimoroni Tiny 2040 has been changed by a seven pin header that connects to an off-board Raspberry Pi Pico RP2040 improvement board. Every DAC has its personal SPI chip choose sign in order that they could be operated independently. Please see the Establishing a Reference Voltage Supply part of that post for the idea of operation behind the facility provide.

Energy Provide Board Design

The ability provide board structure is proven above. It’s the identical structure duplicated thrice. A ±12 volt energy provide connects within the higher left. Centered on the left edge is the 7 pin header that connects to the RP2040 Pico improvement board. On the fitting edge are the three output channels. Section 1 is on the prime, part 2 is within the center, and part 3 is on the backside. These are managed by the DACs linked to /CS1, /CS2, and /CS3 respectively.

Board Meeting

The assembled board is proven above. The LT1010 buffers have small heatsinks to assist with warmth dissipation. I used to be out of right-angle headers on the time so I used a straight header for the connections to the Pico improvement board.

As an alternative of getting a bunch of jumper wires operating between the facility provide board and the Pico improvement board, I constructed one other small board to route the SPI connections from the Pico to the facility provide board. It additionally breaks out a serial port and gives some connections to some {hardware} used on a unique venture.

A photograph of my two boards and the Pico improvement board linked collectively is proven above. That is the purpose at which I want I’d have waited and used a right-angle header on the facility provide board. However, hey, it really works.

The photograph above exhibits the entire take a look at setup. The small board is an FTDI USB to UART board to energy and talk with the Pico improvement board.

Direct Digital Synthesis

This venture makes use of direct digital synthesis to generate three sine waves with a programmable frequency which are separated by 120°. The fundamentals of direct digital synthesis are coated very effectively by articles on the Analog Devices, Digi-Key, and DSP Related web sites amongst others. V. Hunter Adams has an awesome clarification with animations and example Python code and even an RP2040 implementation on his web site. Fairly than get into the basics of DDS on this weblog submit, I’ll cowl simply the small print particular to this implementation.

I chosen the next parameters for my frequency synthesizer:

Parameter	Worth
Sampling Frequency	10 kHz
Tuning Phrase Measurement	32 bits, unsigned
Section Accumulator Measurement	32 bits, unsigned
Scale Measurement	single-precision float
Variety of Outputs	3 outputs separated by 120°

With a ten kHz sampling frequency, the DDS NCO may produce a frequency wherever from to DC to five kHz with an acceptable analog low move filter after the DAC. My precise most frequency in apply will probably be 120% of 70 Hz or 84 Hz. I don’t have a low-pass filter on my energy provide board however since I’m massively oversampled (f_max of 84 Hz vs f_s of 10 kHz), will probably be positive.

I chosen a phrase dimension of 32 bits for each the tuning phrase and part accumulator register since that’s the native dimension of an unsigned integer on the RP2040 microcontroller. I made a decision to make use of a single-precision float for the size. The RP2040 microcontroller has loads of energy to carry out 3 floating level multiplies per pattern interval and utilizing floats was simpler than determining the fixed-point math to carry out comparable scaling utilizing integers.

The ultimate complication is that I want to provide three outputs on the identical frequency however separated by 120°. I got here up with the next block diagram for my three-phase synthesizer. The logic on this block diagram is executed as soon as per pattern interval (10,000 occasions per second):

On the left are the inputs to the logic. These embody the tuning phrase for adjusting the frequency and the size worth for adjusting the ultimate output degree. The part accumulator is proven in purple above. The tuning phrase is added to the final worth of the accumulator, wrapped modulo 2³², then saved for the subsequent run of the code.

240°, 120°, and 0° are added to the output of the part accumulator to provide three alerts offset 120° from one another. A part offset of 240° corresponds to including modulo 2³² a price of two/3 × 2³² = 2863311531 to the output of the part accumulator and a part offset of 120° corresponds to including modulo 2³² a price of 1/3 × 2³² = 1431655765 to the output of the part accumulator.

The phase-to-amplitude converters are proven in orange above. My sine lookup desk solely has 256 entries of 8 bits every subsequently, I’m solely utilizing the higher 8 bits of the part accumulator to provide the sin(x) output. Dropping the decrease 24 bits of the 32 bit part values will get an 8 bit worth that used as an index into the sine lookup desk.

The three sine values are then multiplied by the size and transformed from two’s complement worth to offset binary values for the DACs. Lastly the offset binary sine waves are despatched to the DACs utilizing a SPI interface.

The worth of the tuning phrase by way of the output frequency, f_o, part accumulator width in bits, N, and sampling frequency, f_s, is given by the next method:

$$ tuning phrase = frac{f_o × 2^N}{f_s}$$

In our system, f_o ranges from 0 to 84 Hz, N is 32, and f_o is 10 kHz. Let’s calculate some helpful tuning phrases for our tachometer:

% Max RPM	fo	Tuning Phrase
120%	84.0 Hz	36077725
105%	73.5 Hz	31568010
100%	70.0 Hz	30064771
75%	52.5 Hz	22548578
50%	35.0 Hz	15032386
25%	17.5 Hz	7516193
0%	0 Hz	0

If you understand the worth of the tuning phrase, you may decide the output frequency given the next method:

$$f_o  = frac{tuning phrase × 2^N}{f_s}$$

Software program

The software program for this venture is split into two principal components. The primary half runs on core 0, accepts a % worth from the person to show on the indicator, after which ramps the % displayed on the indicator from the present worth to the person’s entered worth over time. The second half runs on core 1, performs direct digital synthesis of the three-phase sign, and writes the waveform to the DACs.

The Person Enter Thread on Core 0

The person enter thread runs inside the principle loop on core 0. It consists of quick duties that execute as typically as they’ll and sluggish duties that run 100 occasions per second. The pacing of the sluggish duties is carried out utilizing a flag that’s set inside a repeating timer operate that runs at 100 Hz on the default thread pool on core 0. When the principle loop code sees the flag is about, it clears the flag then runs the 100 Hz duties.

Let’s begin with the quick duties:

    // principal loop
    whereas (1) {

        //----------------------------------------
        // quick duties
        //----------------------------------------

I’ve a command line editor that I’ve been utilizing for many years now. The GetCommand operate checks the Pico’s serial port for a brand new character then appends the character to the present command line or takes motion to carry out deletes, rub outs, or  carriage returns.

        // run get command state machine to get a line of enter (non-blocking)
        GetCommand ();

When a whole command line is on the market, the command line editor units the worth of cmd_state to 2. That is the principle loop’s sign that it’s time to course of the command line within the cmd_buffer. The next code detects this then begins splitting out the arguments that are separated by a comma:

        // as soon as a line of enter is acquired, course of it
        if (cmd_state == 2) {
            int index = 0;
            char *buffptr = strtok (cmd_buffer, ",");
            whereas (buffptr != NULL) {

                change (index++) {

The next code takes a proportion entered on the command line and converts it into the goal tuning phrase for the frequency synthesizer:

                    case 0:
                        newPercent = atof (buffptr);
                        newAdderTarget = newPercent / 100.0 * 30064771.0;
                        printf ("newAdderTarget: %ldn", newAdderTarget);
                        break;

The next code processes any remaining arguments then units the cmd_state to 0. The is the command line editor’s sign to reset the command line editor and begin to settle for a brand new line of textual content:

                    default:
                        printf ("detected an unused argumentn");
                        break;
                }
                buffptr = strtok (NULL, ",");
            }
            cmd_state = 0;
        }

After processing the command line arguments, the principle loop checks to see if it’s time to execute the 100 Hz duties:

        //----------------------------------------
        // 100 Hz duties
        //----------------------------------------

        if (flag100) {

Whether it is, it clears the flag then runs the 100 Hz duties:

            flag100 = false;

Like blinking the LED in a elaborate sample:

            // blink led
            if (ledTimer == 0) {
                // led on
                gpio_put (LED_PIN, 1);
            } else if (ledTimer == 25) {
                // led off
                gpio_put (LED_PIN, 0);
            }

            // increment led timer counter, 1 second interval
            if (++ledTimer >= 100) {
                ledTimer = 0;
            }

And ramping the tuning phrase from its present worth to the goal worth set from the command line. The sluggish ramp is carried out to simulate how a tachometer generator linked to an actual engine would possibly ramp or down in RPMs. The tachometer indicator will stutter some and even cease monitoring the RPMs if the frequency is modified abruptly:

            if (newAdderTarget > newAdder) {
                if ((newAdderTarget - newAdder) < fee) {
                    newAdder = newAdderTarget;
                } else {
                    newAdder += fee;
                }
                // printf ("(+) %dn", newAdder);
            } else if (newAdderTarget < newAdder) {
                if ((newAdder - newAdderTarget) < fee) {
                    newAdder = newAdderTarget;
                } else {
                    newAdder -= fee;
                }
                // printf ("(-) %dn", newAdder);
            }

An AC generator’s voltage is proportional to its pace so I ramp the voltage up and down with the frequency. The voltage ramping is topic to limits of 0.2 to 0.5 of full scale and is about to 0 at 0 Hz:

            // compute scale from frequency management phrase
            newScale = (float)newAdder * 0.50 / 36077725.2 + 0.2;
            if (newScale > 0.5) {
                newScale = 0.5;
            }
            if (newAdder == 0) {
                newScale = 0;
            }

The final step is to speak the present tuning phrase and scale values to the direct digital synthesis thread operating on core 1 utilizing a vital part and some international variables:

            // replace pace and path for core 1 ISR
            critical_section_enter_blocking (&scale_critsec);
            sin_adder = newAdder;
            scale = newScale;
            critical_section_exit (&scale_critsec);
        }

The top of the principle loop:

    }

Speaking Between Cores

My code makes use of a vital part to speak the part adder and achieve between the UI thread operating on core 0 and the DDS thread operating on core 1. If one thread is already executing the code in a vital part, the second thread will wait till the primary thread is completed executing the code within the vital part earlier than it begins executing it.

To make use of a vital part, we have to declare it plus some international variables that will probably be shared by the 2 threads:

critical_section_t scale_critsec;
static risky uint32_t sin_adder = 0;
static risky float scale = 0.0;

The vital part have to be initialized earlier than use. I did this simply inside the principle operate earlier than beginning the second core:

    // initialize vital part
    critical_section_init (&scale_critsec);

When the primary thread needs to put in writing these globals, it enters the vital sections, performs the writes, then exits the vital part. This code within the UI thread writes the brand new part adder and new scale to the worldwide variables used to speak with the DDS thread:

   // replace part adder and scale for core 1 ISR
   critical_section_enter_blocking (&scale_critsec);
   sin_adder = newAdder;
   scale = newScale;
   critical_section_exit (&scale_critsec);

When the second thread needs to learn these globals, it enters the vital sections, performs the writes, then exits the vital part. This code provides the part adder to the part accumulator then makes a neighborhood copy of the achieve to use to the output waveforms:

    critical_section_enter_blocking (&scale_critsec);
    sin_phase += sin_adder;
    localScale = scale;
    critical_section_exit

The Direct Digital Synthesis Thread on Core 1

Let’s stroll by means of the direct digital synthesis code. We’re producing sine waves so we have to compute the worth of sin(x) shortly. A desk lookup is probably going sooner than utilizing the Pico’s floating level math library. Though I stuffed the board with the 12-bit MCP4822 DAC, I’m solely utilizing 8 of these bits so a desk with 256 8-bit values is enough:

// sine lookup desk
// spherical(sin((0:255)*2*pi/256)*127);
static const int8_t sine[256] = {
     0,    3,    6,    9,   12,   16,   19,   22,   25,   28,   31,   34,   37,   40,   43,
    46,   49,   51,   54,   57,   60,   63,   65,   68,   71,   73,   76,   78,   81,   83,
    85,   88,   90,   92,   94,   96,   98,  100,  102,  104,  106,  107,  109,  111,  112,
   113,  115,  116,  117,  118,  120,  121,  122,  122,  123,  124,  125,  125,  126,  126,
   126,  127,  127,  127,  127,  127,  127,  127,  126,  126,  126,  125,  125,  124,  123,
   122,  122,  121,  120,  118,  117,  116,  115,  113,  112,  111,  109,  107,  106,  104,
   102,  100,   98,   96,   94,   92,   90,   88,   85,   83,   81,   78,   76,   73,   71,
    68,   65,   63,   60,   57,   54,   51,   49,   46,   43,   40,   37,   34,   31,   28,
    25,   22,   19,   16,   12,    9,    6,    3,    0,   -3,   -6,   -9,  -12,  -16,  -19,
   -22,  -25,  -28,  -31,  -34,  -37,  -40,  -43,  -46,  -49,  -51,  -54,  -57,  -60,  -63,
   -65,  -68,  -71,  -73,  -76,  -78,  -81,  -83,  -85,  -88,  -90,  -92,  -94,  -96,  -98,
  -100, -102, -104, -106, -107, -109, -111, -112, -113, -115, -116, -117, -118, -120, -121,
  -122, -122, -123, -124, -125, -125, -126, -126, -126, -127, -127, -127, -127, -127, -127,
  -127, -126, -126, -126, -125, -125, -124, -123, -122, -122, -121, -120, -118, -117, -116,
  -115, -113, -112, -111, -109, -107, -106, -104, -102, -100,  -98,  -96,  -94,  -92,  -90,
   -88,  -85,  -83,  -81,  -78,  -76,  -73,  -71,  -68,  -65,  -63,  -60,  -57,  -54,  -51,
   -49,  -46,  -43,  -40,  -37,  -34,  -31,  -28,  -25,  -22,  -19,  -16,  -12,   -9,   -6,
    -3
};

The core1_entry operate is the beginning of the thread operating on core 1. It creates a brand new alarm pool operating on the core then begins a repeating timer that runs each 100 µs (10 kHz). As soon as the timer is created, this operate has nothing else to take action it busy waits:

void core1_entry (void)
{
    // native system variables
    alarm_pool_t *core1_alarm_pool;
    struct repeating_timer timer_10kHz;

    // create new alarm pool
    core1_alarm_pool = alarm_pool_create (2, 16);

    // run 10 kHz timer interrupt on core 1
    alarm_pool_add_repeating_timer_us (core1_alarm_pool,
        -100, repeating_timer_callback_10kHz, NULL, &timer_10kHz);

    // nothing else to do on core 1
    whereas (1) {
        tight_loop_contents ();
    }
}

The repeating_timer_callback_10kHz callback is executed by the timer each 100 µs on core 1. This operate writes the subsequent values to the three DAC:

bool repeating_timer_callback_10kHz (struct repeating_timer *t)
 ((uint16_t)dac1B << 4);
    gpio_put (SPI_CS1n_PIN, 0);
    spi_write16_blocking (SPI_IF, &a, 1);
    gpio_put (SPI_CS1n_PIN, 1);

    a = 0xB000 

Lastly, right here’s the operate for writing a 16-bit worth to a DAC:

void dacWrite16 (uint cs_pin, uint16_t a)
{
    // CS low
    asm risky ("nop n nop n nop");
    gpio_put (cs_pin, 0);
    asm risky ("nop n nop n nop");

    // switch knowledge
    spi_write16_blocking (SPI_IF, &a, 1);

    // CS excessive
    asm risky ("nop n nop n nop");
    gpio_put (cs_pin, 1);
    asm risky ("nop n nop n nop");
}

Board and Software program Carry Up

To check the software program and {hardware}, I powered up the boards utilizing a bench provide, linked the Pico’s serial port to a PC, and join the board’s outputs to a few channels on oscilloscope. I entered 100% and captured the picture above on the oscilloscope. It exhibits three 70 Hz alerts at 10.58 V_pp and separated by 120°.

I repeated this process at a number of different % max RPM values. At 5% max RPM, the frequency was down to three.5 Hz and the voltage was all the way down to 4.59 volts as proven within the scope traces above.

% Max RPM	Anticipated Frequency	Anticipated Voltage	Measured Frequency	Measured Voltage
120%	84.0 Hz	10.16 Vpp	84.032 Hz	10.58 Vpp
105%	73.5 Hz	10.16 Vpp	73.736 Hz	10.51 Vpp
100%	70.0 Hz	10.16 Vpp	69.929 Hz	10.51 Vpp
75%	52.5 Hz	10.16 Vpp	52.492 Hz	10.58 Vpp
50%	35.0 Hz	8.30Vpp	35.034 Hz	8.57 Vpp
25%	17.5 Hz	6.18 Vpp	17.520 Hz	6.56 Vpp
5%	3.5 Hz	4.49 Vpp	3.4997 Hz	4.59 Vpp
0%	0 Hz	0 Vpp	0 Hz	0 Vpp

The outcomes of all my measurements are summarized within the desk above. The measured frequencies and voltages had been all inside an appropriate margin of error of the anticipated values.

% Max RPM	Measured Present
120%	72 mA
105%	79 mA
100%	82 mA
75%	108 mA
50%	110 mA
25%	100 mA
5%	81 mA
0%	20 mA

Satisfied the facility provide was working, I hooked up the tachometer to the facility provide and powered it up then measured the present pulled by my three phase-power provide from the bench provide on the identical % max RPM values. These outcomes are proven within the desk above.

I plotted these values within the graph above. The ability provide present will increase from 0% peaking at 110 mA at 50% then declined t0 72 mA at 120% max RPM.

The picture above is a thermal photograph of the LT1010 buffers and their warmth sinks after a number of minutes of operation at 50% max RPM. They’re heat however appear to be holding up OK. The DIP-8 bundle is just not very thermally environment friendly. If I wanted extra present, I may transfer to a extra thermally environment friendly bundle or transfer to a purpose-designed energy op amp.

Measuring the Pace of the Motor

One query that had been lingering at the back of my thoughts was if the tachometer’s motor was actually spinning at 4200 rpm with a 70 Hz enter. If the motor solely had two poles, this may certainly be the case. However nothing says the motor has to have two poles so I devised an experiment to measure the pace of the tachometer motor and thus decide the variety of poles.

I targeted a video digicam taking pictures at 240 fps (really 239.76 fps) in 1080p on the tip of the magnetic drum with the copper drag cup and dial indicators eliminated. I set the digicam for 1/1000 second shutter pace, f/4, and 12 dB of achieve. I used a vibrant, non-flickering LED mild to light up the magnetic drum. I fed a 17.5 Hz sign to the tachometer motor which corresponds to a studying of 25% of most RPM. I then filmed the rotating magnetic drum for a number of seconds.

As soon as the filming was full, I loaded the footage into Closing Minimize Professional and scrubbed forwards and backwards to rely the variety of frames required for the magnetic drum to make one full revolution. A body from the captured footage is proven above. It took 28 frames at 239.76 fps for the drum to make one full revolution. This works out to eight.5629 revolutions per second or 513.77 RPM.

That is roughly 525 RPM which is what a four-pole motor would produce at 17.5 Hz. From this experiment, I concluded that the tachometer’s motor is a four-pole motor. If you happen to look carefully on the earlier photograph of the disassembled motor, you may see 12 coil teams. 12 coil teams divided by three phases is 4 poles thus additional confirming it’s a four-pole motor.

A four-pole motor like this one will spin at a pace of 2100 RPM with a 70 Hz enter so it’s spinning at 2100 RPM at 100%; not 4200 RPM. Remember that is simply the pace of the motor inside to the tachometer indicator that produces a 100% of max RPM studying with a 70 Hz AC enter. This isn’t the pace of the engine or generator at 100% of max RPM.

If I had entry to a stroboscope presumably like an previous automotive timing mild, this measurement would in all probability be a bit extra actual however counting the variety of video frames is enough on condition that the variety of poles must be a fair optimistic integer.

Displaying PC CPU Utilization on the Tachometer

Within the video above, I take advantage of a C# console app to get the % CPU utilization from Home windows and ship the % utilization to the facility provide board. The % utilization is then displayed by the tachometer indicator.

The video exhibits a number of home windows operating on my pc with an inset video overlay displaying the tachometer indicator. The higher proper window is the Home windows Process Supervisor open to the efficiency tab and displaying the CPU load. The window under that’s the console utility displaying the worth of the CPU load from a System.Diagnostics.PerformanceCounter object that’s despatched to the facility provide board and tachometer.

To the left of these home windows, I launch Autodesk Fusion 360, open a design, orbit the design round, then render it. As I full varied duties in Fusion 360, the CPU load varies significantly. The Process Supervisor, console app, and tachometer indicator all monitor the CPU load. The tachometer indicator is a mechanical gadget so it could not point out the height load if the length of the height is simply too brief for it to spin as much as the height degree.

Bonus Content material

Flying at Night time

This indicator has lamps within the housing to light up the dials at night time. In contrast to many different plane indicators that require removing and disassembly of the indicator to relamp them, this indicator has two small lamp holders with bayonet fittings that let relamping with out removing or disassembly.

The bulbs are strange 328 miniature bulbs with midget flange bases. They’re 6 volt, 0.2 amp, 1.2 watt T1-3/4 lamps. The 2 lamps are linked in parallel on to the 2 lamp pins on the rear connector. The indicator seems to be fairly good at night time!

Rear Connector Pinout

The pinout of the tachometer is as follows:

1 – motor ϕA
2 – motor ϕB
3 – motor ϕC
4 – lamp (+)
5 – lamp (−) / chassis floor
6 – NC
7 – NC

The pin numbers are seen contained in the connector shell.

Associated Patents

The earliest patent I may discover associated to utilizing magnets, copper, and Eddy currents dated from 1919. It involved the usage of a tachometer to optimize the separation of cream from milk. A lip on a copper bowl spun between two magnets. The 2 magnets had been hooked up to a hairspring and pointer. When the bowl was spinning on the optimum pace for separating the cream from the milk, the pointer could be centered on the size.

Test it out: Electromagnetic speed-indicator for cream clarifiers and separators.

One other fascinating patent is US2593646A for a magnetic drag tachometer filed by the Kollsman Instrument Company. This patent was the earliest I may discover for a normal objective magnetic drag tachometer indicator. The tachometer on this patent makes use of a extremely conductive disc sandwiched between two rotating magnetic discs moderately than a magnetic drum and conductive cup just like the tachometer examined on this submit.

Closing Ideas

I’d at all times questioned how a tachometer or a speedometer transformed a rotation into a sign of RPM or pace with out spinning the needle off the dashboard. Digging into this plane tachometer answered that query. This indicator was really a bit of precision engineering and sure cutting-edge in its day. Using Eddy currents to exert a drag power on a shaft linked to a needle and the usage of AC synchronous machines to transmit the rotation from a generator to the indicator had been each ingenious.