LTC6946 - Ultralow Noise and Spurious 0.37GHz to 5.7GHz Integer-N Synthesizer with Integrated VCO

Features

  • Low Noise Integer-N PLL with Integrated VCO
  • –226dBc/Hz Normalized In-Band Phase Noise Floor
  • –274dBc/Hz Normalized In-Band 1/f Noise
  • –157dBc/Hz Wideband Output Phase Noise Floor
  • Excellent Spurious Performance
  • Output Divider (1 to 6, 50% Duty Cycle)
  • Output Buffer Muting
  • Low Noise Reference Buffer
  • Charge Pump Current Adjustable from 250μA to 11.2mA
  • Configurable Status Output
  • SPI Compatible Serial Port Control
  • PLLWizard™ Software Design Tool Support

Typical Application

LTC6946 Typical Application
LTC6946 Typical Application

Description

The LTC®6946 is a high performance, low noise, 5.7GHz phase-locked loop (PLL) with a fully integrated VCO, including a reference divider, phase-frequency detector (PFD) with phase-lock indicator, ultralow noise charge pump, integer feedback divider, and VCO output divider. The charge pump contains selectable high and low voltage clamps useful for VCO monitoring.

The integrated low noise VCO uses no external components. It is internally calibrated to the correct output frequency with no external system support.

The part features a buffered, programmable VCO output divider with a range of 1 through 6, providing a wide frequency range.

Packaging

For complete and up to date package information and drawings, please refer to our packaging page

QFN-28

LTC6946 Package Drawing

Order Info

Package Variations and Pricing

Part Number Package Pins Temp Price (1-99) Price (1k)* RoHS Data
LTC6946IUFD-1#PBF QFN 28 I $8.22 $5.75 View
LTC6946IUFD-1#TRPBF QFN 28 I $5.81 View
LTC6946IUFD-2#PBF QFN 28 I $8.22 $5.75 View
LTC6946IUFD-2#TRPBF QFN 28 I $5.81 View
LTC6946IUFD-3#PBF QFN 28 I $8.22 $5.75 View
LTC6946IUFD-3#TRPBF QFN 28 I $5.81 View
Buy NowRequest Samples
* The USA list pricing shown is for BUDGETARY USE ONLY, shown in United States dollars (FOB USA per unit for the stated volume), and is subject to change. International prices may differ due to local duties, taxes, fees and exchange rates. For volume-specific price or delivery quotes, please contact your local Linear Technology sales office or authorized distributor.

Demo Boards

Linear Technology offers many demo boards free of charge to qualified customers. Contact your local sales office or distributor to inquire about a demo board. Certain demo boards are also available for sale via credit card on this website. Demo boards are for evaluation purposes only. It remains the customer’s responsibility to verify proper and reliable operation in the actual end application.

Part Number Description Price Documentation
DC1705B-A LTC6946-1 Demo | Ultralow Noise and Spurious 373MHz to 3.74GHz Integer-N Synthesizer with Integrated VCO (Req DC590). $125.00
DC1705B-B LTC6946-2 Demo | Ultralow Noise and Spurious 513MHz to 4.91GHz Integer-N Synthesizer with Integrated VCO (Req DC590). $125.00
DC1705C-C LTC6946-3 Demo Board | Ultralow Noise and Spurious 640MHz to 5.79GHz Integer-N Synthesizer with Integrated VCO (Req DC2026). $125.00
Buy Now

Companion Boards

Part Number Description Price Documentation
DC1216A-D 100MHz PLL Synthesizer Reference Clock Source $150.00
DC590B USB Serial Controller for Linear Technology QuikEval Demo Boards $50.00
DC2026A Linduino One Isolated Arduino-Compatible Demonstration Board $75.00
Buy Now
Click here to view our complete list of demo boards

Applications

  • Wireless Base Stations (LTE, WiMAX, W-CDMA, PCS)
  • Broadband Wireless Access
  • Military and Secure Radio
  • Test and Measurement

Product Notifications

Please login to your MyLinear account for notifications of datasheet updates, new document releases and LTspice model announcements for your favorite products. If you do not have a MyLinear account you may Sign Up Now.

Forgot your password? Click here.
Need help? Email mylinear@linear.com with questions and comments.

Design Tools

Linduino

Linduino is an Arduino compatible platform for developing and distributing firmware libraries and code for SPI and I²C-compatible integrated circuits. The Linduino One board interfaces to more than 300 QuikEval demonstration cards, supporting a variety of product types including analog-to-digital converters (ADCs)digital-to-analog converters (DACs)power monitors, and more. Firmware libraries for individual devices are written in C and designed to be portable to a wide variety of processors and microcontrollers. Each library has a demonstration program that can be uploaded to the Linduino One platform to allow the circuit and software to be quickly and easily verified.

Click here for more information on Linduino

PLLWizard

Linear Technology PLLWizard is used to communicate with the LTC6945 and LTC6946 synthesizers. It uses the DC590 controller to translate between USB and SPI-compatible serial communications formats. It also includes advanced PLL design and simulation capabilities. You may use it to:

  • Recommend part parameters based on your frequency plan
  • Design noise-optimized loop filters
  • Simulate loop frequency response and stability
  • Simulate VCO and Reference source noise
  • Simulate output noise characterisics and statistics

Click here to download PLLWizard Software Design Tool

Code

Linduino is Linear Technology's Arduino compatible system for developing and distributing firmware libraries and example code for Linear Technology’s integrated circuits. The code below can be downloaded or copied and pasted into your project. Please visit the Linduino Home Page for demo board, manual and setup information.

This part is Code Supported: There is example code available for this part. The code below may rely on other drivers available in the full library.

Download LTC6946 - DC1705B Linduino.INO File

/*!
DC1705B
LTC6946: Ultralow Noise and Spurious 0.37GHz to 5.7GHz Integer-N Synthesizer with Integrated VCO

@verbatim

  Setup:
    Set the terminal baud rate to 115200 and select the newline terminator.
    Refer to Demo Manual DC1705B.
    Ensure all jumpers are installed in the factory default positions.
    Two power supplies are needed for this demo board: a 5v and a 3.3v supply.

Command Description:

                             *****Main Menu*****

    1-  Read All Registers- Selecting this option will cause all the registers to
        be read, stored to variables, and displayed.

    2-  Read All Registers- Selecting this option causes all the registers to be
        written.

    3-  Enter Loop Design- Selecting this option allows the user to enter a loop
        design. Use PLL Wizard to design the loop.

    4-  Manually Set Registers- Allows the user to set all registers manually.

    5-  Increase by One Step Size- Increases the frequency by one step.

    6-  Decrease by One Step Size- Decreases frequency by one step.

    7-  Sweep- Selecting this option causes a sweep in frequency.

    8-  Disable Ref Out- Selecting this option causes the reference out to be
        disabled.

    9-  Enable Ref Out- Selecting this option causes the reference out to be
        enabled.

    10- Power Down- Selecting this option powers down the LTC6946.

    11- Power up- Selecting this option powers up the LTC6946.

USER INPUT DATA FORMAT:
 decimal : 1024
 hex     : 0x400
 octal   : 02000  (leading 0 "zero")
 binary  : B10000000000
 float   : 1024.0

@endverbatim

http://www.linear.com/product/LTC6946

http://www.linear.com/product/LTC6946#demoboards

REVISION HISTORY
$Revision: 1879 $
$Date: 2013-08-15 08:49:40 -0700 (Thu, 15 Aug 2013) $

Copyright (c) 2013, Linear Technology Corp.(LTC)
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of Linear Technology Corp.

The Linear Technology Linduino is not affiliated with the official Arduino team.
However, the Linduino is only possible because of the Arduino team's commitment
to the open-source community.  Please, visit http://www.arduino.cc and
http://store.arduino.cc , and consider a purchase that will help fund their
ongoing work.
*/

/*! @file
    @ingroup LTC6946
*/

#include 
#include 
#include "Linduino.h"
#include "LT_SPI.h"
#include "UserInterface.h"
#include "LT_I2C.h"
#include "QuikEval_EEPROM.h"
#include "LTC6946.h"
#include 
#include 

// Function Declaration
void print_title();             // Print the title block
void print_prompt();            // Print the main menu
void restore_settings();        // Read the PLL settings from EEPROM
void store_settings();          // Store the PLL Settings to the EEPROM

void menu_1_read_reg();         // Sub-menus
void menu_2_write_all();
void menu_3_enter_loop_design();
void menu_4_manually_set_reg();
void menu_5_increase_one_step();
void menu_6_decrease_one_step();
void menu_7_sweep();
void menu_8_disable_ref_out();
void menu_9_enable_ref_out();
void menu_10_power_down();
void menu_11_power_up();

// Global Variables
static uint8_t REG[12];                //!< Register values to be written or read from
static uint8_t ref_out = 0;            //!< Used to keep track of reference out status
static int8_t demo_board_connected;    //!< Demo Board Name stored in QuikEval EEPROM

#define SWEEP_DELAY  500        //!< The delay between steps for the sweep function

//! Initialize Linduino
void setup()
{
  char demo_name[] = "DC1705";    // Demo Board Name stored in QuikEval EEPROM
  uint8_t data;

  quikeval_SPI_init();      //! Configure the spi port for 4MHz SCK
  quikeval_SPI_connect();   //! Connect SPI to main data port
  quikeval_I2C_init();      //! Configure the EEPROM I2C port for 100kHz
  Serial.begin(115200);     //! Initialize the serial port to the PC

  print_title();

  demo_board_connected = discover_demo_board(demo_name);  //! Checks if correct demo board is connected.

  if (!demo_board_connected)
    while (1);                  //! Does nothing if the demo board is not connected

  Serial.print(demo_board.name);
  Serial.println(F(" was found"));

  restore_settings(); //! Checks if settings was stored to external EEPROM

  print_prompt();
}

//! Repeats Linduino loop
void loop()
{
  uint16_t user_command;          // User input command
  if (Serial.available())         // Check for user input
  {
    user_command = read_int();  //! Reads the user command
    if (user_command != 'm')
      Serial.println(user_command);
    switch (user_command)       //! Prints the appropriate submenu
    {
      case 1:
        menu_1_read_reg();
        break;
      case 2:
        menu_2_write_all();
        break;
      case 3:
        menu_3_enter_loop_design();
        break;
      case 4:
        menu_4_manually_set_reg();
        break;
      case 5:
        menu_5_increase_one_step();
        break;
      case 6:
        menu_6_decrease_one_step();
        break;
      case 7:
        menu_7_sweep();
        break;
      case 8:
        menu_8_disable_ref_out();
        break;
      case 9:
        menu_9_enable_ref_out();
        break;
      case 10:
        menu_10_power_down();
        break;
      case 11:
        menu_11_power_up();
        break;
      default:
        Serial.println(F("Incorrect Option"));
        break;
    }
    Serial.println(F("\n*****************************************************************"));
    print_prompt();
  }
}

// Function Definitions

//! Reads all registers from the LTC6946 and displays them.
void menu_1_read_reg()
{
  // Read All Registers
  Serial.println(F("REG(HEX) Value(HEX)"));
  REG[0] = LTC6946_read(LTC6946_CS, LTC6946_REG_H00);
  Serial.print(F("00       "));
  Serial.println(REG[0], HEX);

  REG[1] = LTC6946_read(LTC6946_CS, LTC6946_REG_H01);
  Serial.print(F("01       "));
  Serial.println(REG[1], HEX);

  REG[2] = LTC6946_read(LTC6946_CS, LTC6946_REG_H02);
  Serial.print(F("02       "));
  Serial.println(REG[2], HEX);

  REG[3] = LTC6946_read(LTC6946_CS, LTC6946_REG_H03);
  Serial.print(F("03       "));
  Serial.println(REG[3], HEX);

  REG[4] = LTC6946_read(LTC6946_CS, LTC6946_REG_H04);
  Serial.print(F("04       "));
  Serial.println(REG[4], HEX);

  REG[5] = LTC6946_read(LTC6946_CS, LTC6946_REG_H05);
  Serial.print(F("05       "));
  Serial.println(REG[5], HEX);

  REG[6] = LTC6946_read(LTC6946_CS, LTC6946_REG_H06);
  Serial.print(F("06       "));
  Serial.println(REG[6], HEX);

  REG[7] = LTC6946_read(LTC6946_CS, LTC6946_REG_H07);
  Serial.print(F("07       "));
  Serial.println(REG[7], HEX);

  REG[8] = LTC6946_read(LTC6946_CS, LTC6946_REG_H08);
  Serial.print(F("08       "));
  Serial.println(REG[8], HEX);

  REG[9] = LTC6946_read(LTC6946_CS, LTC6946_REG_H09);
  Serial.print(F("09       "));
  Serial.println(REG[9], HEX);

  REG[10] = LTC6946_read(LTC6946_CS, LTC6946_REG_H0A);
  Serial.print(F("0A       "));
  Serial.println(REG[10], HEX);

  REG[11] = LTC6946_read(LTC6946_CS, LTC6946_REG_H0B);
  Serial.print(F("0B       "));
  Serial.println(REG[11], HEX);
}

//! Writes all registers to the LTC6946 and displays them.
void menu_2_write_all()
{
  // Write All Registers
  LTC6946_write(LTC6946_CS, LTC6946_REG_H01, REG[1]);
  LTC6946_write(LTC6946_CS, LTC6946_REG_H02, REG[2]);
  LTC6946_write(LTC6946_CS, LTC6946_REG_H03, REG[3]);
  LTC6946_write(LTC6946_CS, LTC6946_REG_H04, REG[4]);
  LTC6946_write(LTC6946_CS, LTC6946_REG_H05, REG[5]);
  LTC6946_write(LTC6946_CS, LTC6946_REG_H06, REG[6]);
  LTC6946_write(LTC6946_CS, LTC6946_REG_H07, REG[7]);
  LTC6946_write(LTC6946_CS, LTC6946_REG_H08, REG[8]);
  LTC6946_write(LTC6946_CS, LTC6946_REG_H09, REG[9]);
  LTC6946_write(LTC6946_CS, LTC6946_REG_H0A, REG[10]);
  Serial.println(F("Registers Have Been Written"));
}

//! Allows the user to enter loop designs.
//! Use PLL Wizard to design the Loop
void menu_3_enter_loop_design()
{
  uint8_t O_DIV;
  uint8_t filt;
  uint8_t LKWIN;
  uint8_t B_DIV;
  uint8_t BST;
  uint8_t rfo;
  uint8_t i_cp;
  uint8_t lkcnt;
  uint8_t O_DIV_possible;
  float f_ref;
  float f_STEP;
  float f_rf;
  float dBm;
  float R_DIV;
  float f_PFD;
  float N_DIV;
  float f_VCO;

  Serial.println();
  Serial.println(F("This loop design function uses simple algorithms"));
  Serial.println(F("to set up the LTC6946. It does not guarantee a stable"));
  Serial.println(F("or optimized loop. It is recommended to use PLL Wizard"));
  Serial.println(F("to create the loop design."));
  Serial.println();

  //Enter Loop Design Loop
  Serial.print(F("Enter f_ref(MHz): "));
  f_ref = read_float();
  Serial.println(f_ref, 4);
  Serial.println();

  Serial.print(F("Enter f_ref power ratio in decibels(dBm): "));
  dBm = read_float();
  Serial.println(dBm, 4);
  Serial.println();

  Serial.print(F("Enter f_step(MHz): "));
  f_STEP = read_float();
  Serial.println(f_STEP, 4);
  Serial.println();

  Serial.print(F("Enter f_rf(MHz): "));
  f_rf = read_float();
  Serial.println(f_rf, 4);
  Serial.println();

  Serial.println(F("Loop Design"));

  if (strcmp(demo_board.product_name, "LTC6946-1") == 0)
    O_DIV_possible = O_divide_1(f_rf, &O_DIV);
  else if (strcmp(demo_board.product_name, "LTC6946-2") == 0)
    O_DIV_possible = O_divide_2(f_rf, &O_DIV);
  else if (strcmp(demo_board.product_name, "LTC6946-3") == 0)
    O_DIV_possible = O_divide_3(f_rf, &O_DIV);

  if (!O_DIV_possible)
  {
    Serial.println();
    Serial.println(F("The desired output frequency cannot be synthesized"));
    Serial.println(F("Please Use PLL Wizard to create and find possible loops"));
    Serial.println();
    return;
  }
  Serial.print(F("O DIV: "));
  Serial.println(O_DIV);

  R_DIV = R_divide(f_ref, &f_STEP, O_DIV);
  Serial.print(F("R DIV: "));
  Serial.println(R_DIV);

  f_PFD = f_pfd(f_ref, R_DIV);
  Serial.print(F("f_PFD: "));
  Serial.println(f_PFD);

  N_DIV = N_divide(f_rf, O_DIV, f_PFD);
  Serial.print(F("N DIV: "));
  Serial.println(N_DIV);

  f_VCO = f_vco(f_ref, N_DIV, R_DIV);
  Serial.print(F("f_VCO: "));
  Serial.println(f_VCO);

  B_DIV = B_div(f_PFD);
  Serial.print(F("B DIV: "));
  Serial.println(B_DIV);

  filt = filter(f_ref);
  Serial.print(F("Filter: "));
  Serial.println(filt);

  LKWIN = lkwin(f_PFD);
  Serial.print(F("LKWIN: "));
  Serial.println(LKWIN);

  union
  {
    uint8_t R[2];
    uint16_t code;
  };
  code = R_DIV;
  if (ref_out == 0)
    REG[2] = LTC6946_PDREFO | LTC6946_MTCAL;
  else
    REG[2] = LTC6946_MTCAL;
  REG[3] = B_DIV |R[1];
  REG[4] = R[0];

  union
  {
    uint8_t N[2];
    uint16_t Code;
  };
  Code = N_DIV;
  REG[5] = N[1];
  REG[6] = N[0];
  REG[7] = LTC6946_ALCCAL | LTC6946_ALCULOK | LTC6946_LKEN | LTC6946_CAL; // Required settings to allow proper loop locking

  BST = bst(dBm);
  Serial.print(F("BST: "));
  Serial.println(BST);

  Serial.println();
  Serial.println(F("RF Output Buffer"));
  Serial.println(F("RFO  P_RF(Differential)  P_RF (Single-Ended)"));
  Serial.println(F("0-   -6dBm               -9dBm"));
  Serial.println(F("1-   -3dBm               -6dBm"));
  Serial.println(F("2-   0dBm                -3dBm"));
  Serial.println(F("3-   3dBm                0dBm"));
  Serial.print(F("Enter RFO: "));

  rfo = read_int();
  Serial.println(rfo);

  if (rfo == 0)
    rfo = LTC6946_RFO_0;
  else if (rfo == 1)
    rfo = LTC6946_RFO_1;
  else if (rfo == 2)
    rfo = LTC6946_RFO_2;
  else
    rfo = LTC6946_RFO_3;

  Serial.println();
  Serial.println(F("Charge Pump Current"));
  Serial.println(F("0- 250 uA"));
  Serial.println(F("1- 350 uA"));
  Serial.println(F("2- 500 uA"));
  Serial.println(F("3- 700 uA"));
  Serial.println(F("4- 1.0 mA"));
  Serial.println(F("5- 1.4 mA"));
  Serial.println(F("6- 2.0 mA"));
  Serial.println(F("7- 2.8 mA"));
  Serial.println(F("8- 4.0 mA"));
  Serial.println(F("9- 5.6 mA"));
  Serial.println(F("10- 8.0 mA"));
  Serial.println(F("11- 11.2 mA"));
  Serial.print(F("Enter I_CP: "));

  i_cp = read_int();
  Serial.println(i_cp);

  switch (i_cp)
  {
    case 0:
      i_cp = LTC6946_CP_0;
      break;
    case 1:
      i_cp = LTC6946_CP_1;
      break;
    case 2:
      i_cp = LTC6946_CP_2;
      break;
    case 3:
      i_cp = LTC6946_CP_3;
      break;
    case 4:
      i_cp = LTC6946_CP_4;
      break;
    case 5:
      i_cp = LTC6946_CP_5;
      break;
    case 6:
      i_cp = LTC6946_CP_6;
      break;
    case 7:
      i_cp = LTC6946_CP_7;
      break;
    case 8:
      i_cp = LTC6946_CP_8;
      break;
    case 9:
      i_cp = LTC6946_CP_9;
      break;
    case 10:
      i_cp = LTC6946_CP_10;
      break;
    default:
      i_cp = LTC6946_CP_11;
      break;
  }

  Serial.println();
  Serial.println(F("LKCNT"));
  Serial.println(F("    count"));
  Serial.println(F("0 - 32"));
  Serial.println(F("1 - 128"));
  Serial.println(F("2 - 512"));
  Serial.println(F("3 - 2048"));
  Serial.print(F("Enter LKCNT: "));

  lkcnt = read_int();
  Serial.println(lkcnt);

  if (lkcnt == 3)
    lkcnt = LTC6946_LKCNT_3;
  else if (lkcnt == 2)
    lkcnt = LTC6946_LKCNT_2;
  else if (lkcnt == 1)
    lkcnt = LTC6946_LKCNT_1;
  else
    lkcnt = LTC6946_LKCNT_0;

  REG[8] = BST | filt | O_DIV | rfo;
  REG[9] = i_cp | LKWIN | lkcnt;
  REG[10] = LTC6946_CPCHI | LTC6946_CPCLO; // Sets charge pump

  store_settings();
}

//! Allows the user to set all registers manually
void menu_4_manually_set_reg()
{
  uint16_t user_command;          // User input command
  // Manually Set Registers
  do
  {
    Serial.println(F("1-REG 0x01"));
    Serial.println(F("2-REG 0x02"));
    Serial.println(F("3-REG 0x03"));
    Serial.println(F("4-REG 0x04"));
    Serial.println(F("5-REG 0x05"));
    Serial.println(F("6-REG 0x06"));
    Serial.println(F("7-REG 0x07"));
    Serial.println(F("8-REG 0x08"));
    Serial.println(F("9-REG 0x09"));
    Serial.println(F("10-REG 0x0A"));
    Serial.println(F("m-Main Menu"));
    Serial.print(F("Enter a command:"));

    user_command = read_int();  // Read the user command
    if (user_command != 'm')
      Serial.println(user_command);

    switch (user_command)
    {
      case 1:
        // REG 0x01
        Serial.print("Enter REG 0x01: ");
        REG[1] = read_int();
        Serial.println(REG[1], HEX);
        break;
      case 2:
        // REG 0x02
        Serial.print("Enter REG 0x02: ");
        REG[2] = read_int();
        Serial.println(REG[2], HEX);
        break;
      case 3:
        // REG 0x03
        Serial.print("Enter REG 0x03: ");
        REG[3] = read_int();
        Serial.println(REG[3], HEX);
        break;
      case 4:
        // REG 0x04
        Serial.print("Enter REG 0x04: ");
        REG[4] = read_int();
        Serial.println(REG[4], HEX);
        break;
      case 5:
        // REG 0x05
        Serial.print("Enter REG 0x05: ");
        REG[5] = read_int();
        Serial.println(REG[5], HEX);
        break;
      case 6:
        // REG 0x06
        Serial.print("Enter REG 0x06: ");
        REG[6] = read_int();
        Serial.println(REG[6], HEX);
        break;
      case 7:
        // REG 0x07
        Serial.print("Enter REG 0x07: ");
        REG[7] = read_int();
        Serial.println(REG[7], HEX);
        break;
      case 8:
        // REG 0x08
        Serial.print("Enter REG 0x08: ");
        REG[8] = read_int();
        Serial.println(REG[8], HEX);
        break;
      case 9:
        // REG 0x09
        Serial.print("Enter REG 0x09: ");
        REG[9] = read_int();
        Serial.println(REG[9], HEX);
        break;
      case 10:
        // REG 0x0A
        Serial.print("Enter REG 0x0A: ");
        REG[10] = read_int();
        Serial.println(REG[10], HEX);
        break;
      default:
        if (user_command != 'm')
          Serial.println("Incorrect Option");
        break;
    }
  }
  while (user_command !='m');
}

//! Increases the frequency by one step
void menu_5_increase_one_step()
{
  union
  {
    uint8_t N[2];
    uint16_t Code;
  };
  // Increase by One Step Size
  N[1] = LTC6946_read(LTC6946_CS, LTC6946_REG_H05);
  N[0] = LTC6946_read(LTC6946_CS, LTC6946_REG_H06);
  Code ++;
  LTC6946_write(LTC6946_CS, LTC6946_REG_H05, N[1]);
  LTC6946_write(LTC6946_CS, LTC6946_REG_H06, N[0]);
}

//! Decreases frequency by one step
void menu_6_decrease_one_step()
{
  union
  {
    uint8_t N[2];
    uint16_t Code;
  };
  // decrease by One Step Size
  N[1] = LTC6946_read(LTC6946_CS, LTC6946_REG_H05);
  N[0] = LTC6946_read(LTC6946_CS, LTC6946_REG_H06);
  Code --;
  LTC6946_write(LTC6946_CS, LTC6946_REG_H05, N[1]);
  LTC6946_write(LTC6946_CS, LTC6946_REG_H06, N[0]);
}

//! This function causes a sweep in frequency
void menu_7_sweep()
{
  uint8_t data;
  uint16_t sweep_temp;

  union
  {
    uint8_t N[2];
    uint16_t Code;
  };

  // Sweep
  N[1] = LTC6946_read(LTC6946_CS, LTC6946_REG_H05);
  N[0] = LTC6946_read(LTC6946_CS, LTC6946_REG_H06);
  sweep_temp = Code;
  do
  {
    LTC6946_write(LTC6946_CS, LTC6946_REG_H05, N[1]);
    LTC6946_write(LTC6946_CS, LTC6946_REG_H06, N[0]);
    delay(SWEEP_DELAY);
    Code ++;
    Serial.print("N DIV: ");
    Serial.println(Code);
    data = LTC6946_read(LTC6946_CS, LTC6946_REG_H00);
  }
  while ((data && 0x04));

  Code = sweep_temp;
  LTC6946_write(LTC6946_CS, LTC6946_REG_H05, N[1]);
  LTC6946_write(LTC6946_CS, LTC6946_REG_H06, N[0]);

  do
  {
    LTC6946_write(LTC6946_CS, LTC6946_REG_H05, N[1]);
    LTC6946_write(LTC6946_CS, LTC6946_REG_H06, N[0]);
    delay(SWEEP_DELAY);
    Code --;
    Serial.print("N DIV: ");
    Serial.println(Code);
    data = LTC6946_read(LTC6946_CS, LTC6946_REG_H00);
  }
  while ((data && 0x04));

  Code = sweep_temp;
  LTC6946_write(LTC6946_CS, LTC6946_REG_H05, N[1]);
  LTC6946_write(LTC6946_CS, LTC6946_REG_H06, N[0]);

  Serial.println("Sweep Has Been Completed");
  Serial.println();
}

//! This function causes the reference out to be disabled
void menu_8_disable_ref_out()
{
  // Turn off Ref Out
  ref_out = 0;
  LTC6946_write(LTC6946_CS, LTC6946_REG_H02, (LTC6946_PDREFO | LTC6946_MTCAL));
  Serial.println("REF Out Has Been Turned Off");
}

//! This function causes the reference out to be enabled
void menu_9_enable_ref_out()
{
  // Turn On Ref Out
  ref_out = 1;
  LTC6946_write(LTC6946_CS, LTC6946_REG_H02, LTC6946_MTCAL);
  Serial.println("REF Out Has Been Turned On");
}

//! This function powers down the LTC6946
void menu_10_power_down()
{
  // Power Down
  if (ref_out == 0)
    LTC6946_write(LTC6946_CS, LTC6946_REG_H02, (LTC6946_PDREFO | LTC6946_MTCAL | LTC6946_PDALL));
  else
    LTC6946_write(LTC6946_CS, LTC6946_REG_H02, (LTC6946_MTCAL | LTC6946_PDALL));
}

//! This function powers up the LTC6946
void menu_11_power_up()
{
  // Power up
  if (ref_out == 0)
    LTC6946_write(LTC6946_CS, LTC6946_REG_H02, (LTC6946_PDREFO | LTC6946_MTCAL));
  else
    LTC6946_write(LTC6946_CS, LTC6946_REG_H02, (LTC6946_MTCAL));
}

//! Prints the title block when program first starts.
void print_title()
{
  Serial.println(F("*****************************************************************"));
  Serial.println(F("* DC1705 Demonstration Program                                  *"));
  Serial.println(F("*                                                               *"));
  Serial.println(F("* This program demonstrates how to send data to the LTC6946     *"));
  Serial.println(F("* Ultra Low Noise & Spurious Integer-N Synthesizer with         *"));
  Serial.println(F("* Integrated VCO.                                               *"));
  Serial.println(F("* Set the baud rate to 115200 and select the newline terminator.*"));
  Serial.println(F("*                                                               *"));
  Serial.println(F("*****************************************************************"));
  Serial.println();
}

//! Prints main menu.
void print_prompt()
{
  Serial.println(F("\nCommand Summary:"));
  Serial.println(F("  1-Read All Registers"));
  Serial.println(F("  2-Write All Registers"));
  Serial.println(F("  3-Design Loop"));
  Serial.println(F("  4-Manually Set Register"));
  Serial.println(F("  5-Increase by One Step Size"));
  Serial.println(F("  6-Decrease by One Step Size"));
  Serial.println(F("  7-Sweep Through Step Sizes"));
  Serial.println(F("  8-Disable Ref Out"));
  Serial.println(F("  9-Enable Ref Out"));
  Serial.println(F("  10-Power Down"));
  Serial.println(F("  11-Power Up"));
  Serial.println("");
  Serial.print(F("Enter a command:"));
}

//! Store PLL settings to nonvolatile EEPROM on demo board
void store_settings()
// Store the PLL Settings to the EEPROM
{
  eeprom_write_int16(EEPROM_I2C_ADDRESS, EEPROM_CAL_KEY, EEPROM_CAL_STATUS_ADDRESS);         // Cal key
  for (uint8_t i = 2; i <= 10 ; i++)
    eeprom_write_byte(EEPROM_I2C_ADDRESS,(char) REG[i], EEPROM_CAL_STATUS_ADDRESS + i);
  Serial.println(F("PLL Settings Stored to EEPROM"));
}

//! Read stored PLL settings from nonvolatile EEPROM on demo board
void restore_settings()
// Read the PLL settings from EEPROM
{
  int16_t cal_key;
  // read the cal key from the EEPROM
  eeprom_read_int16(EEPROM_I2C_ADDRESS, &cal_key, EEPROM_CAL_STATUS_ADDRESS);
  if (cal_key == EEPROM_CAL_KEY)
  {
    // PLL Settings has been stored, read PLL Settings
    for (uint8_t i = 2; i <= 10 ; i++)
      eeprom_read_byte(EEPROM_I2C_ADDRESS,(char *) ®[i], EEPROM_CAL_STATUS_ADDRESS + i);
    Serial.println(F("PLL Settings Restored"));
  }
  else
    Serial.println(F("PLL Settings not found"));
}

Download LTC6946 Linduino .CPP File

/*!
    LTC6946: Ultralow Noise and Spurious 0.37GHz to 5.7GHz Integer-N Synthesizer with Integrated VCO

@verbatim

The LTC6946 is a high performance, low noise, 5.7GHz phase-locked loop (PLL) 
with a fully integrated VCO, including a reference divider, phase-frequency 
detector (PFD) with phase-lock indicator, ultralow noise charge pump, integer 
feedback divider, and VCO output divider. The charge pump contains selectable 
high and low voltage clamps useful for VCO monitoring. 

@endverbatim


http://www.linear.com/product/LTC6946

http://www.linear.com/product/LTC6946#demoboards

REVISION HISTORY
$Revision: 1844 $
$Date: 2013-08-08 15:11:32 -0700 (Thu, 08 Aug 2013) $

Copyright (c) 2013, Linear Technology Corp.(LTC)
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of Linear Technology Corp.

The Linear Technology Linduino is not affiliated with the official Arduino team.
However, the Linduino is only possible because of the Arduino team's commitment
to the open-source community.  Please, visit http://www.arduino.cc and
http://store.arduino.cc , and consider a purchase that will help fund their
ongoing work.
*/

//! @defgroup LTC6946 LTC6946: Ultralow Noise and Spurious 0.37GHz to 5.7GHz Integer-N Synthesizer with Integrated VCO

/*! @file
    @ingroup LTC6946
    Library for LTC6946 Ultralow Noise and Spurious 0.37GHz to 5.7GHz Integer-N Synthesizer with Integrated VCO
*/

#include 
#include 
#include "Linduino.h"
#include "LT_SPI.h"
#include "LTC6946.h"
#include 

// Read 8-bit code from the LTC6946
uint8_t LTC6946_read(uint8_t cs, int8_t address)
{
  LT_union_int16_2bytes rx;

  spi_transfer_word(cs, (address | 0x01)<<8 , &rx.LT_uint16);
  
  return(rx.LT_byte[0]);
}

// Write 8-bit code to the LTC6946
void LTC6946_write(uint8_t cs, uint8_t address, uint8_t Data)
{
  LT_union_int16_2bytes rx;
  
  spi_transfer_word(cs, (address<<8) | Data, &rx.LT_uint16);
}

// Calculates the O DIV for the LTC6946-1 given the output frequency in MHz
uint8_t O_divide_1(float f_rf, uint8_t *o_div)
{
  if ((f_rf >= 2240) && (f_rf <= 3740))
  {
    *o_div = LTC6946_O_DIV_1;
    return(1);
  }
  if ((f_rf >= 1120) && (f_rf <= 1870))
  {
    *o_div = LTC6946_O_DIV_2;
    return(1);
  }
  if ((f_rf >= 747) && (f_rf <= 1247))
  {
    *o_div = LTC6946_O_DIV_3;
    return(1);
  }
  if ((f_rf >= 560) && (f_rf <= 935))
  {
    *o_div = LTC6946_O_DIV_4;
    return(1);
  }
  if ((f_rf >= 448) && (f_rf <= 748))
  {
    *o_div = LTC6946_O_DIV_5;
    return(1);
  }
  if ((f_rf >= 373) && (f_rf <= 623))
  {
    *o_div = LTC6946_O_DIV_6;
    return(1);
  }
  return(0);
}

// Calculates the O DIV for the LTC6946-2 given the output frequency in MHz
uint8_t O_divide_2(float f_rf, uint8_t *o_div)
{
  if ((f_rf >= 3080) && (f_rf <= 4910))
  {
    *o_div = LTC6946_O_DIV_1;
    return(1);
  }
  if ((f_rf >= 1540) && (f_rf <= 2455))
  {
    *o_div = LTC6946_O_DIV_2;
    return(1);
  }
  if ((f_rf >= 1027) && (f_rf <= 1637))
  {
    *o_div = LTC6946_O_DIV_3;
    return(1);
  }
  if ((f_rf >= 770) && (f_rf <= 1228))
  {
    *o_div = LTC6946_O_DIV_4;
    return(1);
  }
  if ((f_rf >= 616) && (f_rf <= 982))
  {
    *o_div = LTC6946_O_DIV_5;
    return(1);
  }
  if ((f_rf >= 513) && (f_rf <= 818))
  {
    *o_div = LTC6946_O_DIV_6;
    return(1);
  }
  return(0);
}

// Calculates the O DIV for the LTC6946-3 given the output frequency in MHz
uint8_t O_divide_3(float f_rf, uint8_t *o_div)
{
  if ((f_rf >= 3840) && (f_rf <= 5790))
  {
    *o_div = LTC6946_O_DIV_1;
    return(1);
  }
  if ((f_rf >= 1920) && (f_rf <= 2895))
  {
    *o_div = LTC6946_O_DIV_2;
    return(1);
  }
  if ((f_rf >= 1280) && (f_rf <= 1930))
  {
    *o_div = LTC6946_O_DIV_3;
    return(1);
  }
  if ((f_rf >= 960) && (f_rf <= 1448))
  {
    *o_div = LTC6946_O_DIV_4;
    return(1);
  }
  if ((f_rf >= 768) && (f_rf <= 1158))
  {
    *o_div = LTC6946_O_DIV_5;
    return(1);
  }
  if ((f_rf >= 640) && (f_rf <= 965))
  {
    *o_div = LTC6946_O_DIV_6;
    return(1);
  }
  return(0);
}

// Calculates the R DIV
float R_divide(float f_REF, float *f_step, uint8_t O_div)
{
  float r_div, temp;
  int8_t i;
  for (i = 1; i <= 10; i++)
  {
    temp = *f_step / i;
    r_div = f_REF/(temp*(float)O_div);      //! 1) Calculate R Divide
    if ((r_div - floor(r_div)) <= .0001)    //! 2) Round
    {
      *f_step = temp;
      return(floor(r_div));
    }
    else if ((r_div - floor(r_div)) >= 0.9999)
    {
      *f_step = temp;
      return (floor(r_div +1));
    }
  }
  return(r_div);
}

// Calculates the f_PFD
float f_pfd(float f_REF, float R_div)
{
  float f_pfd;
  f_pfd = f_REF/R_div; //! Calculate frequency of PFD
  return(f_pfd);
}

// Calculates the N DIV
float N_divide(float f_RF, uint8_t O_div, float f_pfd)
{
  float n_div;
  n_div = ((float)O_div*f_RF)/f_pfd;    //! 1) Calculate N divide
  return(n_div);
}

// Calculates VCO in MHz
float f_vco(float f_REF, float N_div, float R_div)
{
  float f_vco;
  f_vco = (f_REF*N_div)/R_div;  //! 1) Calculate VCO
  return(f_vco);
}

// Chooses B DIV value and B DIV
uint8_t B_div(float f_pfd)  // The PFD in MHz
{
  if (f_pfd >= 77)
    return (LTC6946_BD_11);
  if ((f_pfd >= 58) && (f_pfd <= 77))
    return (LTC6946_BD_10);
  if ((f_pfd >= 38) && (f_pfd <= 58))
    return (LTC6946_BD_9);
  if ((f_pfd >= 29) && (f_pfd <= 38))
    return (LTC6946_BD_8);
  if ((f_pfd >= 19) && (f_pfd <= 29))
    return (LTC6946_BD_7);
  if ((f_pfd >= 14) && (f_pfd <= 19))
    return (LTC6946_BD_6);
  if ((f_pfd >= 9.6) && (f_pfd <= 14))
    return (LTC6946_BD_5);
  if ((f_pfd >= 7.2) && (f_pfd <= 9.6))
    return (LTC6946_BD_4);
  if ((f_pfd >= 4.8) && (f_pfd <= 7.2))
    return (LTC6946_BD_3);
  if ((f_pfd >= 3.6) && (f_pfd <= 4.8))
    return (LTC6946_BD_2);
  if ((f_pfd >= 2.4) && (f_pfd <= 3.6))
    return (LTC6946_BD_1);
  if (f_pfd <= 2.4)
    return (LTC6946_BD_0);
    return(0xFF);
}

// Calculates the Filter
uint8_t filter(float f_REF)     // RF out frequency in MHz
{
  if (f_REF < 20)
    return(LTC6946_FILT_3);
  if ((f_REF >= 20) && (f_REF <= 50))
    return(LTC6946_FILT_1);
  if (f_REF > 50)
    return(LTC6946_FILT_0);
}

// Calculates Lock Count
uint8_t lkwin(float f_pfd)  // The PFD in MHz
{
  if (f_pfd <=0.55)
    return(LTC6946_LKWIN_3);
  if (f_pfd <=1.77)
    return(LTC6946_LKWIN_2);
  if (f_pfd <=5)
    return(LTC6946_LKWIN_1);
  if (f_pfd > 5)
    return(LTC6946_LKWIN_0);
}

// Calculates BST value
uint8_t bst(float dbm) // Input signal level in dBm
{
  float V_p_p;
  V_p_p = pow(50, 0.5)*pow(10, ((dbm - 21.0)/20.0));
  if (V_p_p < 2.0 )
    return(LTC6946_BST_1);
  return(LTC6946_BST_0);
}

Download LTC6946 Linduino Header File

/*!
 LTC6946: Ultralow Noise and Spurious 0.37GHz to 5.7GHz Integer-N Synthesizer with Integrated VCO

@verbatim
 SPI DATA FORMAT (MSB First):

 Write Sequence:
       Byte #1                    Byte #2
 MOSI: A6 A5 A4 A3 A2 A1 A0 W   D7 D6 D5 D4 D3 D2 D1 D0
 MISO: X  X  X  X  X  X  X  X   X  X  X  X  X  X  X  X

 Read Sequence:
       Byte #1                    Byte #2
 MOSI: A6 A5 A4 A3 A2 A1 A0 R   X  X  X  X  X  X  X  X
 MISO: X  X  X  X  X  X  X  X   D7 D6 D5 D4 D3 D2 D1 D0

 W    : SPI Write (0)
 R    : SPI Read  (1)
 Ax   : Address
 Dx   : Data Bits
 X    : Don't care

@endverbatim

http://www.linear.com/product/LTC6946

http://www.linear.com/product/LTC6946#demoboards

REVISION HISTORY
$Revision: 1877 $
$Date: 2013-08-14 14:58:41 -0700 (Wed, 14 Aug 2013) $

Copyright (c) 2013, Linear Technology Corp.(LTC)
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of Linear Technology Corp.

The Linear Technology Linduino is not affiliated with the official Arduino team.
However, the Linduino is only possible because of the Arduino team's commitment
to the open-source community.  Please, visit http://www.arduino.cc and
http://store.arduino.cc , and consider a purchase that will help fund their
ongoing work.
*/

/*! @file
    @ingroup LTC6946
    Header for LTC6946 Ultralow Noise and Spurious 0.37GHz to 5.7GHz Integer-N Synthesizer with Integrated VCO
*/

#ifndef LTC6946_H
#define LTC6946_H

//! Define the SPI CS pin
#ifndef LTC6946_CS
#define LTC6946_CS QUIKEVAL_CS  //! SPI Chip Select Pin
#endif

/*!

The value of the register are shifted to the left to account for the R/W bit 
| LTC6946 Register| Value |
| :---------------| :---: |
| LTC6946_REG_H00 | 0x00  |
| LTC6946_REG_H01 | 0x02  |
| LTC6946_REG_H02 | 0x04  |
| LTC6946_REG_H03 | 0x06  |
| LTC6946_REG_H04 | 0x08  |
| LTC6946_REG_H05 | 0x0A  |
| LTC6946_REG_H06 | 0x0C  |
| LTC6946_REG_H07 | 0x0E  |
| LTC6946_REG_H08 | 0x10  |
| LTC6946_REG_H09 | 0x12  |
| LTC6946_REG_H0A | 0x14  |
| LTC6946_REG_H0B | 0x16  |
*/
/*! @name LTC6946 Register Map
@{ */
// LTC6946 Register Map
#define LTC6946_REG_H00 0x00
#define LTC6946_REG_H01 0x02
#define LTC6946_REG_H02 0x04
#define LTC6946_REG_H03 0x06
#define LTC6946_REG_H04 0x08
#define LTC6946_REG_H05 0x0A
#define LTC6946_REG_H06 0x0C
#define LTC6946_REG_H07 0x0E
#define LTC6946_REG_H08 0x10
#define LTC6946_REG_H09 0x12
#define LTC6946_REG_H0A 0x14
#define LTC6946_REG_H0B 0x16
//! @} */

/*! Bitwise OR options together to create byte for register

| Power Down Options (Reg h02) | Value | Description                                    |
| :----------------------------| :---: | :--------------------------------------------- |
| LTC6946_POR                  | 0x00  | Force Power-On Reset                           |
| LTC6946_OMUTE                | 0x02  | Mutes RF Output                                |
| LTC6946_MTCAL                | 0x04  | Mutes Output During Calibration                |
| LTC6946_PDREFO               | 0x06  | Power Down REFO                                |
| LTC6946_PDOUT                | 0x08  | Power Down O_DIV, RF Output Buffer             |
| LTC6946_PDVCO                | 0x0A  | Power Down VCO, N_DIV                          |
| LTC6946_PDPLL                | 0x0C  | Power Down REF, REFO, R_DIV, PFD, CPUMP, N_DIV |
| LTC6946_PDALL                | 0x0C  | Full Chip Power Down                           |


| B DIV Options (Reg h03) | Value | f_PFD(MHz)  |
| :-----------------------| :---: | :---------- |
| LTC6946_BD_0            | 0x00  | <2.5        |
| LTC6946_BD_1            | 0x10  | 2.4 to 3.6  |
| LTC6946_BD_2            | 0x20  | 3.6 to 4.8  |
| LTC6946_BD_3            | 0x30  | 4.8 to 7.2  |
| LTC6946_BD_4            | 0x40  | 7.2 to 9.6  |
| LTC6946_BD_5            | 0x50  | 9.6 to 14   |
| LTC6946_BD_6            | 0x60  | 14 to 19    |
| LTC6946_BD_7            | 0x70  | 19 to 29    |
| LTC6946_BD_8            | 0x80  | 7.2 to 9.6  |
| LTC6946_BD_9            | 0x90  | 9.6 to 14   |
| LTC6946_BD_10           | 0xA0  | 14 to 19    |
| LTC6946_BD_11           | 0xB0  | 19 to 29    |

| Register h07              | Value | Description                                                                   |
| :------------------------ | :---: | :---------------------------------------------------------------------------- |
| LTC6946_LKEN              | 0x01  | Enable Lock Indicator                                                         |
| LTC6946_CAL               | 0x02  | Calibrate the LTC6946                                                         |
| LTC6946_ALCULOK           | 0x10  | Auto Enable ALC when PLL Unlocked                                             |
| LTC6946_ALCCAL            | 0x20  | Auto Enable ALC During CAL Operation                                          |
| LTC6946_ALCMON            | 0x40  | Enable ALC Monitoring for Status Flags Only; Doesn't Enable Amplitude Control |
| LTC6946_ALCEN             | 0x80  | Always enable ALC(Overrides ALCCAL, ALCMON, and ALCULOK)                      |

| Register h08              | Value | Description                                   |
| :------------------------ | :---: | :-------------------------------------------- |
| BST options               |       | V_REF                                         |
| LTC6946_BST_0             | 0x00  | >=2.0V_P-P                                    |
| LTC6946_BST_1             | 0x80  | <2.0V_P-P                                     |
| Filter Options            |       | f_REF                                         |
| LTC6946_FILT_0            | 0x00  | >50MHz                                        |
| LTC6946_FILT_1            | 0x20  | 20MHz to 50MHz                                |
| LTC6946_FILT_3            | 0x60  | <20MHz                                        |
| RF Output Buffer          |       | P_RF(Differential);   P_RF(Single-Ended)      |
| LTC6946_RFO_0             | 0x00  | -6dBm;               -9dBm                    |
| LTC6946_RFO_1             | 0x08  | -3dBm;               -6dBm                    |
| LTC6946_RFO_2             | 0x10  | 0dBm;                -3dBm                    |
| LTC6946_RFO_3             | 0x18  | 3dBm;                0dBm                     |
| O DIV Options             |       | VCO Freq Range(MHz)                           |
|                           |       | LTC6946-1;      LTC6946-1;      LTC6946-1     |
| LTC6946_O_DIV_1           | 0x01  | 2240 to 3740;   3080 to 4910;   3840 to 5790  |
| LTC6946_O_DIV_2           | 0x02  | 1120 to 1870;   1540 to 2455;   1920 to 2895  |
| LTC6946_O_DIV_3           | 0x03  | 747 to 1247;    1027 to 1637;   1280 to 1930  |
| LTC6946_O_DIV_4           | 0x04  | 560 to 935;    770 to 1228;    960 to 1448    |
| LTC6946_O_DIV_5           | 0x05  | 448 to 748;     616 to 982;     768 to 1158   |
| LTC6946_O_DIV_6           | 0x06  | 373 to 623;     513 to 818;     640 to 965    |


| Register h09              | Value | Description |
| :------------------------ | :---: | :---------- |
| LKCNT Options             |       | Counts      |
| LTC6946_LKCNT_0           | 0x00  | 32          |
| LTC6946_LKCNT_1           | 0x10  | 128         |
| LTC6946_LKCNT_2           | 0x20  | 512         |
| LTC6946_LKCNT_3           | 0x30  | 2048        |
| LKWIN Options             |       | f_PFD       |
| LTC6946_LKWIN_0           | 0x00  | > 5MHz      |
| LTC6946_LKWIN_1           | 0x40  | <= 5MHz     |
| LTC6946_LKWIN_2           | 0x80  | <= 1.7MHz   |
| LTC6946_LKWIN_3           | 0xC0  | <= 550kHz   |
| CP Options                |       | I_CP        |
| LTC6946_CP_0              | 0x00  | 250uA       |
| LTC6946_CP_1              | 0x01  | 350uA       |
| LTC6946_CP_2              | 0x02  | 500uA       |
| LTC6946_CP_3              | 0x03  | 700uA       |
| LTC6946_CP_4              | 0x04  | 1.0mA       |
| LTC6946_CP_5              | 0x05  | 1.4mA       |
| LTC6946_CP_6              | 0x06  | 2.0mA       |
| LTC6946_CP_7              | 0x07  | 2.8mA       |
| LTC6946_CP_8              | 0x08  | 4.0mA       |
| LTC6946_CP_9              | 0x09  | 5.6mA       |
| LTC6946_CP_10             | 0x0A  | 8.0mA       |
| LTC6946_CP_11             | 0x0B  | 11.2mA      |

| Register h0A              | Value | Description                       |
| :------------------------ | :---: | :-------------------------------- |
| Charge Pump Functions     |       |                                   |
| LTC6946_CPDN              | 0x01  | Force Sinked Current              |
| LTC6946_CPUP              | 0x02  | Force Source Current              |
| LTC6946_CPRST             | 0x04  | Reset PFD                         |
| LTC6946_CPWIDE            | 0x08  | Extend Current Pulse Width        |
| LTC6946_CPINV             | 0x10  | Invert PFD Phase                  |
| LTC6946_CPMID             | 0x20  | Enable Mid-Voltage Bias           |
| LTC6946_CPCLO             | 0x40  | Enable Low Voltage Output Clamp   |
| LTC6946_CPCHI             | 0x80  | Enable High Voltage Output Clamp  |

*/
/*! @name Register Bit Map
@{ */

// Power Down Options (Reg h02)
#define LTC6946_POR     0x01    // Force Power-On Reset
#define LTC6946_OMUTE   0x02    // Mutes RF Output
#define LTC6946_MTCAL   0x04    // Mutes Output During Calibration
#define LTC6946_PDREFO  0x08    // Power Down REFO
#define LTC6946_PDOUT   0x10    // Power Down O_DIV, RF Output Buffer
#define LTC6946_PDVCO   0x20    // Power Down VCO, N_DIV
#define LTC6946_PDPLL   0x40    // Power Down REF, REFO, R_DIV, PFD, CPUMP, N_DIV
#define LTC6946_PDALL   0x80    // Full Chip Power Down

// B DIV Options (Reg h03)         f_PFD(MHz)
#define LTC6946_BD_0    0x00    // <2.5
#define LTC6946_BD_1    0x10    // 2.4 to 3.6
#define LTC6946_BD_2    0x20    // 3.6 to 4.8
#define LTC6946_BD_3    0x30    // 4.8 to 7.2
#define LTC6946_BD_4    0x40    // 7.2 to 9.6
#define LTC6946_BD_5    0x50    // 9.6 to 14
#define LTC6946_BD_6    0x60    // 14 to 19
#define LTC6946_BD_7    0x70    // 19 to 29
#define LTC6946_BD_8    0x80    // 29 to 38
#define LTC6946_BD_9    0x90    // 38 to 58
#define LTC6946_BD_10   0xA0    // 58 to 77
#define LTC6946_BD_11   0xB0    // >77

// Lock Indicator(Reg h07)
#define LTC6946_LKEN    0x01    // Enable Lock Indicator

// Calibrate (Reg h07)
#define LTC6946_CAL     0x02    // Calibrate the LTC6946

// Automatic Level Control (Reg h07)
#define LTC6946_ALCULOK 0x10    // Auto Enable ALC when PLL Unlocked
#define LTC6946_ALCCAL  0x20    // Auto Enable ALC During CAL Operation
#define LTC6946_ALCMON  0x40    // Enable ALC Monitoring for Status Flags Only; Doesn't Enable Amplitude Control
#define LTC6946_ALCEN   0x80    // Always enable ALC(Overrides ALCCAL, ALCMON, and ALCULOK)

// BST Options (Reg h08)           V_REF
#define LTC6946_BST_0   0x00    // >=2.0V_P-P
#define LTC6946_BST_1   0x80    // <2.0V_P-P

// Filter Options (Reg h08)        f_REF
#define LTC6946_FILT_0  0x00    // >50MHz
#define LTC6946_FILT_1  0x20    // 20MHz to 50MHz
#define LTC6946_FILT_3  0x60    // <20MHz

// RF Output Buffer (Reg h08)      P_RF(Differential)   P_RF(Single-Ended)
#define LTC6946_RFO_0   0x00    // -6dBm                -9dBm
#define LTC6946_RFO_1   0x08    // -3dBm                -6dBm
#define LTC6946_RFO_2   0x10    // 0dBm                 -3dBm
#define LTC6946_RFO_3   0x18    // 3dBm                 0dBm

//                                 VCO Freq Range(MHz)
// O DIV Options (Reg h08)         LTC6946-1      LTC6946-1      LTC6946-1
#define LTC6946_O_DIV_1 0x01    // 2240 to 3740   3080 to 4910   3840 to 5790
#define LTC6946_O_DIV_2 0x02    // 1120 to 1870   1540 to 2455   1920 to 2895
#define LTC6946_O_DIV_3 0x03    // 747 to 1247    1027 to 1637   1280 to 1930
#define LTC6946_O_DIV_4 0x04    // 560 to 935     770 to 1228    960 to 1448
#define LTC6946_O_DIV_5 0x05    // 448 to 748     616 to 982     768 to 1158
#define LTC6946_O_DIV_6 0x06    // 373 to 623     513 to 818     640 to 965

// LKCNT Options (Reg h09)         Counts
#define LTC6946_LKCNT_0 0x00    // 32
#define LTC6946_LKCNT_1 0x10    // 128
#define LTC6946_LKCNT_2 0x20    // 512
#define LTC6946_LKCNT_3 0x30    // 2048

// LKWIN Options (Reg h09)         f_PFD
#define LTC6946_LKWIN_0 0x00    // > 5MHz
#define LTC6946_LKWIN_1 0x40    // <= 5MHz
#define LTC6946_LKWIN_2 0x80    // <= 1.7MHz
#define LTC6946_LKWIN_3 0xC0    // <= 550kHz

// CP Options (Reg h09)            I_CP
#define LTC6946_CP_0    0x00    // 250uA
#define LTC6946_CP_1    0x01    // 350uA
#define LTC6946_CP_2    0x02    // 500uA
#define LTC6946_CP_3    0x03    // 700uA
#define LTC6946_CP_4    0x04    // 1.0mA
#define LTC6946_CP_5    0x05    // 1.4mA
#define LTC6946_CP_6    0x06    // 2.0mA
#define LTC6946_CP_7    0x07    // 2.8mA
#define LTC6946_CP_8    0x08    // 4.0mA
#define LTC6946_CP_9    0x09    // 5.6mA
#define LTC6946_CP_10   0x0A    // 8.0mA
#define LTC6946_CP_11   0x0B    // 11.2mA

// Charge Pump Functions (Reg h0A)
#define LTC6946_CPDN    0x01    // Force Sinked Current
#define LTC6946_CPUP    0x02    // Force Source Current
#define LTC6946_CPRST   0x04    // Reset PFD
#define LTC6946_CPWIDE  0x08    // Extend Current Pulse Width
#define LTC6946_CPINV   0x10    // Invert PFD Phase
#define LTC6946_CPMID   0x20    // Enable Mid-Voltage Bias
#define LTC6946_CPCLO   0x40    // Enable Low Voltage Output Clamp
#define LTC6946_CPCHI   0x80    // Enable High Voltage Output Clamp
//! @} */

//! Read 8-bit code from the LTC6946
//! @return Returns the register data.
uint8_t LTC6946_read(uint8_t cs,    //!< Chip Select Pin
                     int8_t address //!< Register address for the LTC6946.
                    );

//! Write 8-bit code to the LTC6946
void LTC6946_write(uint8_t cs,    //!< Chip Select Pin
                   uint8_t address, //!< Register address for the LTC6946.
                   uint8_t Data     //!< 8-bit data to be written to register
                  );

//! Calculates the O DIV for the LTC6946-1 given the output frequency in MHz
//! @return the O Divider if successful, 0 if there is no solution.
uint8_t O_divide_1(float f_rf,      //!< RF out frequency in MHz
                   uint8_t *o_div   //!< The calculated O DIV
                  );

//! Calculates the O DIV for the LTC6946-2 given the output frequency in MHz
//! @return the O Divider if successful, 0 if there is no solution.
uint8_t O_divide_2(float f_rf,      //!< RF out frequency in MHz
                   uint8_t *o_div   //!< The calculated O DIV
                  );

//! Calculates the O DIV for the LTC6946-3 given the output frequency in MHz
//! @return the O Divider if successful, 0 if there is no solution.
uint8_t O_divide_3(float f_rf,      //!< RF out frequency in MHz
                   uint8_t *o_div   //!< The calculated O DIV
                  );

//! Calculates the R DIV
//! @return Returns the R divider
float R_divide(float f_REF,     //!< Reference clock in MHz
               float *f_step,   //!< Step size in MHz
               uint8_t O_div    //!< O divider
              );

//! Calculates the f_PFD
//! @return Returns the PFD in MHz
float f_pfd(float f_REF,    //!< Reference clock in MHz
            float R_div     //!< R divider
           );

//! Calculates the N DIV
//! @return Returns the N divider
float N_divide(float f_RF,      //!< RF out frequency in MHz
               uint8_t O_div,   //!< O divider
               float f_pfd      //!< PFD in MHz
              );

//! Calculates VCO in MHz
//! @return Returns the VCO in MHz
float f_vco(float f_REF,    //!< RF out frequency in MHz
            float N_div,    //!< N divider
            float R_div     //!< R divider
           );

//! Chooses B DIV value and B DIV
//! @return Returns the B DIV value or 0xFF if failed to calculate
uint8_t B_div(float f_pfd   //!< The PFD in MHz
             );

//! Calculates the Filter
//! @return Returns the Calculated Filter
uint8_t filter(float f_REF  //!< RF out frequency in MHz
              );

//! Calculates Lock Count
//! @return Returns the Lock Count
uint8_t lkwin(float f_pfd   //!< The PFD in MHz
             );

//! Calculates BST value
//! @return Returns the BST
uint8_t bst(float dbm   //!< Input signal level in dBm
           );

#endif  // LTC6946_H

Technical Support