Aug 26

DIY HP/Agilent 53131A 010 High Stability Timebase Option

Having obtained a reasonably reliable 10MHz lab reference (see here) I decided to calibrate my Frequency Counter only to find that the stock oscillator provided in the HP 53151A is absolutely terrible – a joke even! I looked around for an “010 High Stability Timebase Option” but they are rare — and if you can find one not installed in a counter they are very expensive – in the few hundred dollars range at least — and buying one from HP is, well, expensive in the extreme. There are many second-hand 10MHz OCXO modules available, these are mostly stripped from old telecommunications, satellite or cellular equipment so they are plentiful and relatively cheap to buy too. I decided to make a clone 010 option board for my counter using a second-hand OCXO bought from e-bay. I designed a PCB to get a professional finish as well as a reliable upgrade for my counter. The main goal was to make an option board that just like the original could be automatically calibrated using the internal software and front panel controls so I had to use the same DAC chip (which is now obsolete) and basic topology of the original option board to make it work.

The result speaks for its self – with the OCXO running as the timebase, the counter is able to measure the 10MHz source it was calibrated with to a precision of 100th of one cycle with no error!

The schematic is pretty simple and self-explainatory. The counter seems to need a differential square wave clock drive, this is created using a high-speed differential output comparator part LM361. The DAC is an AD7243 part from Analog Devices, this part is now obsolete and not recommended for new designs but they are still available from various sources, albeit quite expensive parts. It would have been possible to design in a newer part but for the small number of units I wanted to make, it seemed a bit pointless to go to the effort as the recommended newer part actually requires different serial signaling, and this would have required some kind of serial protocol converter microcontroller. The DAC is driven by the counters microprocessor to calibrate and tune the timebase. The ADR4550 provides a high stability 5V reference for the ADC. The rest of the circuitry is basically power supply and signal filtering.

The PCB layout was designed to accommodate different OCXO footprints making it flexible. As well as supporting OCXO’s there are footprints for SMA connectors and you can even use a low-cost TCXO which cannot be automatically calibrated but is still a considerably better option than the oscillator built into the counter.

PCB’s Available : See here

The finished board fits really neatly inside the counter, and even fits around my previous Hard Power Switch Modification project.

Various Pictures

IMG_6028.JPG
IMG_6028.JPG
IMG_6026.JPG
IMG_6026.JPG
IMG_6031.JPG
IMG_6031.JPG
IMG_6034.JPG
IMG_6034.JPG
IMG_6024.JPG
IMG_6024.JPG
IMG_6038.JPG
IMG_6038.JPG

Catch you next time….

If you found this post useful or interesting, please consider giving me a tib.
Tibs are pocket-change for the internet™.
Aug 24

Five Decade Programmable Capacitor – A Low Cost Solution

As a follow-up to a previous blog post where I created a seven decade programmable resistor substation for use during electronic circuit prototyping and development, I thought I would expand on the concept and develop a decade capacitor solution to complement the decade resistor board. This new board is a five decade programmable capacitance and is in exactly the same form factor as the previous resistor project. The capacitance can be programmed in the range of 100pF through 9.9999uF in 1000pF increments. The tolerance of the capacitance is five (5%) percent.

My goal was to keep costs down while making the board usable and functional and reliable so I continued to use the 0.1″ jumpers I had used for the resistor board. However, to achieve a programmable capacitance you need to use small capacitors and parallel them to obtain the desired value, and the challenge here was how to achieve that with jumpers. In the end I took the simple approach and provided 10 jumpers for each decade, but instead of a two-pin header row I used a three pin header row so each of the 10 jumpers has an “on” (1) or “off” (0) position. I concede that the board is slightly more difficult to use than the resistor board, and thats simply because of the number of jumpers – dialling in a value involves moving multiple jumpers per decade. However, with the cost to use high quality switches I felt that the infrequent nature of use for the board, it was a reasonable compromise both in terms of design theme consistency and cost.

When working on linear circuits, in particular around op amps, PSU’s and other circuitry that needs response tuning, having a decade capacitance to hand when prototyping is a very valuable tool – not for day to day use of course, but when you are doing that specific job that needs this, its worth its weight in gold.

If you are interested in one of these boards I have had a bunch of them made and am selling them. You can buy them on http://tindie.com or if you prefer on e-bay – simply search for “gerrysweeney” on either system to find the items.

If you found this post useful or interesting, please consider giving me a tib.
Tibs are pocket-change for the internet™.
Aug 10

10MHz Rubidium Frequency Standard and Signal Distribution Amp Follow-Up

This is a follow-up to my previous article here. When testing the 1 PPS output I found some strange output which needed further investigation. I also decided to make further use of the microcontroller and status LED to indicate the 1 PPS signal to provide a degree of visual confidence that the frequency standard was working.

Various Pictures

IMG_5966.JPG
IMG_5966.JPG
IMG_5965.JPG
IMG_5965.JPG
IMG_5964.JPG
IMG_5964.JPG
IMG_5963.JPG
IMG_5963.JPG
IMG_5962.JPG
IMG_5962.JPG
IMG_5961.JPG
IMG_5961.JPG
IMG_5960.JPG
IMG_5960.JPG
IMG_5959.JPG
IMG_5959.JPG
IMG_5958.JPG
IMG_5958.JPG
IMG_5956.JPG
IMG_5956.JPG
IMG_5957.JPG
IMG_5957.JPG
IMG_5954.JPG
IMG_5954.JPG
IMG_5955.JPG
IMG_5955.JPG

The 1 PPS Channel
Here is the outline schematic of the digital channel of the video amp that is now used for the 1 PPS signal.

The fast comparator used in this circuit is an LT1016

The Micro-controller
When I first tried to implement this I used (or tried to use) the edge trigger interrupt capability which on the face of it should have been the perfect solution. However, no matter what I tried I could not get it to work, the best I managed to achieve was getting it to work some of the time, but it was very random. I suspect this was down to the way in which the PIC12X handles interrupts and context state saving implemented by the compiler, I read somewhere on the microchip forums that this issue *could* be resolved by upgrading to the PRO version of the compiler…..hmmmmmmm. Anyway, I decided to change tact and poll for the 1PPS signal which meant I also had to construct a really simple pulse stretcher circuit to ensure I was able to catch each pulse. Not as elegant as an interrupt-driven solution but it works. I think the more advanced PIC18Fxxx series micro controllers would have worked using interrupts but those are big chips and I was already committed to the PIC12F675.

Here is the schematic for the micro controller which now also monitors the 1 PPS output of the RBS. The shaded area is what has been added to the circuit since the previous article.

Here is the firmware source code with the 1PPS implementation added. Its implemented as a simple state machine in run mode, I have tried to keep the code simple to read.

#include <xc.h>

// PIC12F675 Configuration Bit Settings

// CONFIG
#pragma config FOSC  = INTRCIO  // Oscillator Selection bits (Internal oscillator: GPIO on GP4/GP5)
#pragma config WDTE  = OFF      // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF      // Power-Up Timer Enable bit (PWRT disabled)
#pragma config MCLRE = OFF      // GP3/MCLR pin function select (GP3/MCLR pin function is digital I/O, MCLR internally tied to VDD)
#pragma config BOREN = OFF      // Brown-out Detect Enable bit (BOD disabled)
#pragma config CP    = OFF      // Code Protection bit (Program Memory code protection is disabled)
#pragma config CPD   = OFF      // Data Code Protection bit (Data memory code protection is disabled)

// IMPLEMENTATION STRATEGY
//
// PIN ASSIGNMENTS
//   2 = RFS_RDY signal from Pin 6 (GPIO5)
//   4 - 1PPS signal
//   5 - Front Panel LED
//

// We are running the chip at 4Mhz
#define XTAL_FREQ 4000000

#define CLK_1PPS GPIObits.GPIO4
#define LED_STATUS GPIObits.GPIO2
#define RFS_READY GPIObits.GPIO5

void main(void)
{
    // Used as LED state machine control variable
    char _led_state = 0;

    ADCON0bits.ADON = 0;    // Turn off the ADC
    ANSELbits.ANS = 0;      // Make all inputs digital
    VRCON = 0;              // Turn off the internal voltage reference
    CMCON = 0x7;            // Turn off the comparator

    // Set up our I/O pins
    TRISIObits.TRISIO2 = 0; // Make GPIO2 an output - LED
    TRISIObits.TRISIO4 = 1; // Make GPIO4 an input - 1PPS counter input
    TRISIObits.TRISIO5 = 1; // Make GPIO5 an input - RFS_READY

    while(1)
    {
        if(RFS_READY == 0)
        {
            // This is when we are in run mode.

            // We are polling the 1 PPS signal, if we sense a "1" we set the
            // _led_state variable to the number of 10ms periods you want. In
            // this case I want about 80ms. Once this is set the state machine
            // below will hold the LED on and wait 10ms until ir reaches 2,
            // and then normal state resumes, the end result being an LED thats
            // lit normally, and pulses brightly for about 80ms on each 1pps
            // count.
            if(CLK_1PPS == 1)
                _led_state = 10;

            // This is a simple state machine that will run the LED
            // at one third power by outputting a 33% duty cycle square
            // wave. Each time around the loop the state variable will
            // count 0-1-2-0-1-2...etc LED on for 0, and off 1 & 2.
            // When the 1PPS interrypt is fired, the state machine
            // holds the LED on at full brightness (100% duty)
            switch(_led_state)
            {
            case 0:
                LED_STATUS = 1;
                _led_state = 1;
                break;

            case 1:
                LED_STATUS = 0;
                _led_state = 2;
                break;

            case 2:
                LED_STATUS = 0;
                _led_state = 0;
                break;

            default:
                _led_state--;
                LED_STATUS = 1;
                _delay(10000);
                break;
            }
        }
        else
        {
            // If we get in here we are in warm-up mode. We blink the
            // LED with a short on period (20%) and a long off period (80%)
            // about three blinks a second.
            if(LED_STATUS == 0)
            {
                LED_STATUS = 1;
                _delay(75000);
            }
            else
            {
                LED_STATUS = 0;
                _delay(300000);
            }
        }
    }
}

Catch you next time….

If you found this post useful or interesting, please consider giving me a tib.
Tibs are pocket-change for the internet™.
Aug 03

Build a 10MHz Rubidium Frequency Standard and Signal Distribution Amp for my Lab

Having gotten myself a Rubidium Frequency Standard I found that the unit on its own is not that useful, its really just a component and needs really a supporting PSU and a decent enclosure to make it useful. I was searching around for something suitable when I was directed to a robust quality unit being sold on e-bay for just £20 with an unbelievable level of re-usable content and turned out to be an almost perfect solution to making the Rubidium Standard a useful Lab item. Rarely does such a fine marriage of junk bits come together to make something really useful.

I had a lot to cover, the whole thing was built in an afternoon and as a result this is a long video at 1 hour 16 mins so be prepared…

The PIC Micro-controller – PIC12F675
The original plan was to use the PIC for three functions, the first was to make the power LED flash while the RFS was warming up and on solid when locked. The second was to generate a 1 PPS signal from the 10Mhz signal and the third was to generate a PWM signal to control the fan speed. As it turns out the RFS already has a 1 PPS output on Pin 6 of the DB9 connector so there was no need for this. It also transpired that the only fan I had to hand was a three wire fixed speed fan, so I also did not need the PWM signal, this left me with just the power LED to deal with which is what the PIC ended up controlling. Here is the schematic for the PIC and the source code.

#include <xc.h>

// Using MPLAB-X and the XC8 compiler, both are free from Microchip.com. I am using this on OSX (Mac) and with an ICD3 for programming.

// PIC12F675 Configuration Bit Settings

// CONFIG
#pragma config FOSC = INTRCIO   // Oscillator Selection bits (Internal oscillator: GPIO on GP4/GP5)
#pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF      // Power-Up Timer Enable bit (PWRT disabled)
#pragma config MCLRE = OFF      // GP3/MCLR pin function select (GP3/MCLR pin function is digital I/O, MCLR internally tied to VDD)
#pragma config BOREN = OFF      // Brown-out Detect Enable bit (BOD disabled)
#pragma config CP = OFF         // Code Protection bit (Program Memory code protection is disabled)
#pragma config CPD = OFF        // Data Code Protection bit (Data memory code protection is disabled)

// IMPLEMENTATION STRATEGY
//
// PIN ASSIGNMENTS
//   2 = RBS_RDY (GPIO5)
//   5 - POWER_STATUS_LED
//

// We are running the chip at 4Mhz
#define XTAL_FREQ 4000000

#define RBS_RDY GPIObits.GPIO5
#define POWER_LED GPIObits.GPIO2

void main(void)
{
    ADCON0bits.ADON = 0;    // Turn off the ADC
    ANSELbits.ANS = 0;      // Make all inputs digital
    VRCON = 0;              // Turn off the internal voltage reference
    CMCON - 0x7;            // Turn off the comparator

    // Set up our I/O pins
    TRISIObits.TRISIO2 = 0; // Make GPIO2 an output
    TRISIObits.TRISIO5 = 1; // Make GPIO5 an input

    while(1)
    {
        if(RBS_RDY == 0)
        {
            POWER_LED = 1;
        }
        else
        {
            if(POWER_LED == 0)
            {
                POWER_LED = 1;
                _delay(100000);
            }
            else
            {
                POWER_LED = 0;
                _delay(400000);
            }
        }
    }
}

The Video Amp – Extron ADA 6 300MX HV
The video amp unit I used in this hack is made by Extron and the model number (on the front panel) is ADA 6 300MX HV. When I communicated with the seller, he said he had about 30 of them, so if this is useful to you and you want to make your own I would go grab yourself one before they are gone. The basic outline schematic for an input channel is here:

The video op amp chip used in this unit is a CLC409, the Texas Instruments CLC409 Data Sheet data sheet is attached to this article.

The heat sink I have ordered can be found on e-bay, search for “150x25x60mm Aluminum Heat Sink for LED”.

The switch mode PSU I used can also be found on e-bay, search for “Enclosed Power Supply SMPS,15V,2.4A,36W, it is made by TDK-Lambda and the part number is LS35-15”

See you next time.

If you found this post useful or interesting, please consider giving me a tib.
Tibs are pocket-change for the internet™.