ADF4002,HMC704 配置

最新推荐文章于 2024-08-02 09:50:31 发布
最新推荐文章于 2024-08-02 09:50:31 发布
阅读量5.8k 收藏 14
点赞数 2
分类专栏： 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a379039233/article/details/44465123
版权

   /*
 *     主要功能：                                                              *
 *             (1)通用I/O模拟实现SPI接口功能                                   *
 *             (2)鉴相器ADF4002                                                *
 *                a.参考频率：40MHz                                            *
 *                b.鉴相频率: 40MHz   *
 *                c.输出频率：400MHz                               *
 *             (3)鉴相器HMC704LP4E                                             *
 *                a.参考频率：40MHz                                            *
 *                b.鉴相频率: 40MHz   *
 *                c.输出频率：1280MHz                               *
 *             (4)鉴相器HMC704LP4E                       *
 *                a.参考频率：40MHz                                            *
 *                b.鉴相频率: 40MHz   *
 *                c.输出频率：1360MHz                               *
 *                                                                             *
 *     单片机型号: C8051F330                                                   *

 ******************************/

#include "C8051F330.h"
#define OPEN_MODE


sbit SCK_Pad  = P0^3;
sbit SDI_Pad  = P0^4;
sbit LE2_Pad  = P0^5;
sbit SDO2_Pad = P0^6;
sbit LE1_Pad  = P0^7;
sbit SDO3_Pad = P1^1;
sbit LE3_Pad  = P1^2;
sbit CEN_Pad  = P1^3;


void Oscillator_Init()
{
    OSCICN = 0x82;     // 使能内部H-F振荡器，SYSCLK为12.25MHz
            RSTSRC = 0x04;       // 使能时钟丢失检测器，检测到时钟丢失时触发复位
            CLKSEL = 0x00;       // 系统时钟取自内部高频振荡器，分频数由OSCICN寄存器中的IFCN位决定。
}


void PCA_Init()
{
    PCA0MD    &= ~0x40;  // 禁止看门狗定时器
            PCA0MD    = 0x00; // PCA计数器的时钟源为系统时钟的12分频
    PCA0H     = 0x00;
    PCA0L     = 0x00;
    PCA0CPL2  = 0xFF; // PCA捕捉模块2低字节置0xFF,超时间隔64.2ms 
    PCA0MD    |= 0x40; // PCA模块2用作看门狗定时器
    PCA0CN    = 0x40;    // 启动PCA计数器/定时器
}


void Port_IO_Init()
{
    P0MDIN  = 0xFF;
    P0MDOUT = 0xB8;
    P0SKIP  = 0x00;
    P1MDIN  = 0xFF;
    P1MDOUT = 0x0C;
    P1SKIP  = 0x00;
    XBR0    = 0x00;
    XBR1    = 0x40;
}


void delay(unsigned int time)
{
    
    
    CKCON |= 0x02;
    TMOD  |= 0x01;
    TH0    = 0xFE;
    TL0    = 0xFF;
    ET0    = 0x0;
    TR0    = 0x1;
    while(time)
    {
        TF0 = 0x0;
        while(!TF0)
        {
            PCA0CPH2 = 0x00;
        }
        TH0 = 0xFE;
        TL0 = 0xFE;
        time--;
    }
    TR0    = 0x0;
}


void ADF4002_Write(unsigned long value)
{
    unsigned char i;
    unsigned long send_data;
    unsigned char valueL,valueM,valueH;
    
    
    send_data = value;
    valueL = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    valueM = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    valueH = (unsigned char)(send_data & 0x000000FF);
    
    
    LE1_Pad = 0x0;
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(valueH & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        valueH <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(valueM & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        valueM <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(valueL & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        valueL <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    LE1_Pad = 0x1;
}


void HMC704_ReadA(unsigned char addr,unsigned long *value)
{
    unsigned char i,j;
    unsigned char send_data;
    unsigned char receive_data;
#ifdef HMC_MODE
    SDI_Pad = 0x1;
    LE2_Pad = 0x1; 
    
    
    send_data = addr;
    send_data <<= 1;
    send_data |= 0x80;
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(send_data & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        send_data <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    *value = 0x00;
    for(j=0; j<3; j++)
    {
        send_data = 0x00;
        receive_data = 0x00;
        for(i=0; i<8; i++)
        {
            SCK_Pad = 0x0;
            receive_data <<= 1;
            if(SDO2_Pad)
            {
                receive_data |= 0x01;
            }
            if(send_data & 0x80)
            {
                SDI_Pad = 0x1;
            }
            else
            {
                SDI_Pad = 0x0;
            }
            send_data <<= 1;
            delay(1);
            SCK_Pad = 0x1;
            delay(1);
        }
        *value <<= 8;
        *value |= receive_data;
    }
    LE2_Pad = 0x0;
#endif
    
    
#ifdef OPEN_MODE
    LE2_Pad = 0x1;
    //First cycle
    for(j=0; j<2; j++)
    { 
        send_data = 0x00;
        for(i=0; i<8; i++)
        {
            SCK_Pad = 0x0;
            if(send_data & 0x80)
            {
                SDI_Pad = 0x1;
            }
            else
            {
                SDI_Pad = 0x0;
            }
            send_data <<= 1;
            delay(1);
            SCK_Pad = 0x1;
            delay(1);
        }
    }
    send_data = addr & 0x1F;
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(send_data & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        send_data <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    send_data = addr;
    send_data <<= 3;
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(send_data & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        send_data <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
        if(i>4)
        {
            LE2_Pad = 0x0; 
        }
    }
    //Second cycle 
    *value = 0x00;
    LE2_Pad = 0x1;
    for(j=0; j<2; j++)
    { 
        send_data = 0x00;
        receive_data = 0x00;
        for(i=0; i<8; i++)
        {
            SCK_Pad = 0x0;
            receive_data <<= 1;
            if(SDO2_Pad)
            {
                receive_data |= 0x01;
            }
            if(send_data & 0x80)
            {
                SDI_Pad = 0x1;
            }
            else
            {
                SDI_Pad = 0x0;
            }
            send_data <<= 1;
            delay(1);
            SCK_Pad = 0x1;
            delay(1);
        }
        *value <<= 8;
        *value |= receive_data;
    }
    *value &= 0x7FFF;
    send_data = addr & 0x1F;
    receive_data = 0x00;
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        receive_data <<= 1;
        if(SDO2_Pad)
        {
            receive_data |= 0x01;
        }
        if(send_data & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        send_data <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    *value <<= 8;
    *value |= receive_data;
    send_data = addr;
    send_data <<= 3;
    receive_data = 0x00;
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        receive_data <<= 1;
        if(SDO2_Pad)
        {
            receive_data |= 0x01;
        }
        if(send_data & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        send_data <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
        if(i>1)
        {
            LE2_Pad = 0x0; 
        }
    }
    *value <<= 1;
    *value |= (receive_data >> 7);
#endif
}


void HMC704_ReadB(unsigned char addr,unsigned long *value)
{
    unsigned char i,j;
    unsigned char send_data;
    unsigned char receive_data;
#ifdef HMC_MODE
    SDI_Pad = 0x1;
    LE3_Pad = 0x1; 
    
    
    send_data = addr;
    send_data <<= 1;
    send_data |= 0x80;
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(send_data & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        send_data <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    *value = 0x00;
    for(j=0; j<3; j++)
    {
        send_data = 0x00;
        receive_data = 0x00;
        for(i=0; i<8; i++)
        {
            SCK_Pad = 0x0;
            receive_data <<= 1;
            if(SDO3_Pad)
            {
                receive_data |= 0x01;
            }
            if(send_data & 0x80)
            {
                SDI_Pad = 0x1;
            }
            else
            {
                SDI_Pad = 0x0;
            }
            send_data <<= 1;
            delay(1);
            SCK_Pad = 0x1;
            delay(1);
        }
        *value <<= 8;
        *value |= receive_data;
    }
    LE3_Pad = 0x0;
#endif
    
    
#ifdef OPEN_MODE
    LE3_Pad = 0x1;
    //First cycle
    for(j=0; j<2; j++)
    { 
        send_data = 0x00;
        for(i=0; i<8; i++)
        {
            SCK_Pad = 0x0;
            if(send_data & 0x80)
            {
                SDI_Pad = 0x1;
            }
            else
            {
                SDI_Pad = 0x0;
            }
            send_data <<= 1;
            delay(1);
            SCK_Pad = 0x1;
            delay(1);
        }
    }
    send_data = addr & 0x1F;
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(send_data & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        send_data <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    send_data = addr;
    send_data <<= 3;
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(send_data & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        send_data <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
        if(i>4)
        {
            LE3_Pad = 0x0; 
        }
    }
    //Second cycle 
    *value = 0x00;
    LE3_Pad = 0x1;
    for(j=0; j<2; j++)
    { 
        send_data = 0x00;
        receive_data = 0x00;
        for(i=0; i<8; i++)
        {
            SCK_Pad = 0x0;
            receive_data <<= 1;
            if(SDO3_Pad)
            {
                receive_data |= 0x01;
            }
            if(send_data & 0x80)
            {
                SDI_Pad = 0x1;
            }
            else
            {
                SDI_Pad = 0x0;
            }
            send_data <<= 1;
            delay(1);
            SCK_Pad = 0x1;
            delay(1);
        }
        *value <<= 8;
        *value |= receive_data;
    }
    *value &= 0x7FFF;
    send_data = addr & 0x1F;
    receive_data = 0x00;
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        receive_data <<= 1;
        if(SDO3_Pad)
        {
            receive_data |= 0x01;
        }
        if(send_data & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        send_data <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    *value <<= 8;
    *value |= receive_data;
    send_data = addr;
    send_data <<= 3;
    receive_data = 0x00;
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        receive_data <<= 1;
        if(SDO3_Pad)
        {
            receive_data |= 0x01;
        }
        if(send_data & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        send_data <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
        if(i>1)
        {
            LE3_Pad = 0x0; 
        }
    }
    *value <<= 1;
    *value |= (receive_data >> 7);
#endif
}


void HMC704_WriteA(unsigned char addr,unsigned long value)
{
    unsigned char i;
    unsigned long send_data;
    unsigned char value1,value2,value3,value4;
#ifdef HMC_MODE
    send_data   = addr;
    send_data <<=24;
    send_data  |= (value & 0x00FFFFFF);
    send_data <<= 1; 
            value4 = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    value3 = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    value2 = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    value1 = (unsigned char)(send_data & 0x000000FF);
    
    SDI_Pad = 0x0;
    LE2_Pad = 0x1; 
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value1 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value1 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value2 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value2 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value3 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value3 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value4 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value4 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    LE2_Pad = 0x0;
#endif
    
    
#ifdef OPEN_MODE
    send_data   = (value & 0x00FFFFFF);
    send_data <<= 8;
    send_data  |= (addr << 3);
    value4 = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    value3 = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    value2 = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    value1 = (unsigned char)(send_data & 0x000000FF);
    LE2_Pad = 0x1; 
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value1 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value1 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value2 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value2 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value3 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value3 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value4 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value4 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
        if(i>4)
        {
            LE2_Pad = 0x0;
        }
    }
    LE2_Pad = 0x1;
    delay(1);
    LE2_Pad = 0x0;
#endif 
}


void HMC704_WriteB(unsigned char addr,unsigned long value)
{
    unsigned char i;
    unsigned long send_data;
    unsigned char value1,value2,value3,value4;
#ifdef HMC_MODE
    send_data   = addr;
    send_data <<=24;
    send_data  |= (value & 0x00FFFFFF);
    send_data <<= 1; 
            value4 = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    value3 = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    value2 = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    value1 = (unsigned char)(send_data & 0x000000FF);
    
    SDI_Pad = 0x0;
    LE3_Pad = 0x1; 
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value1 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value1 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value2 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value2 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value3 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value3 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value4 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value4 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    LE3_Pad = 0x0;
#endif
    
#ifdef OPEN_MODE
    send_data   = (value & 0x00FFFFFF);
    send_data <<= 8;
    send_data  |= (addr << 3);
    value4 = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    value3 = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    value2 = (unsigned char)(send_data & 0x000000FF);
    send_data >>= 8;
    value1 = (unsigned char)(send_data & 0x000000FF);
    LE3_Pad = 0x1; 
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value1 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value1 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value2 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value2 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value3 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value3 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
    }
    for(i=0; i<8; i++)
    {
        SCK_Pad = 0x0;
        if(value4 & 0x80)
        {
            SDI_Pad = 0x1;
        }
        else
        {
            SDI_Pad = 0x0;
        }
        value4 <<= 1;
        delay(1);
        SCK_Pad = 0x1;
        delay(1);
        if(i>4)
        {
            LE3_Pad = 0x0;
        }
    }
    LE3_Pad = 0x1;
    delay(1);
    LE3_Pad = 0x0;
#endif 
}


unsigned long chip1_id;
unsigned long chip2_id;
//-----------------------------------------------------------------------------
// MAIN Routine
//-----------------------------------------------------------------------------
void main(void)
{
    PCA0MD &= ~0x40;
    Oscillator_Init();
    Port_IO_Init();
    PCA_Init();
    EA = 0x1;
    delay(1000);
    LE1_Pad = 0x1;
    LE2_Pad = 0x0;
    LE3_Pad = 0x0;
    SDI_Pad = 0x1;
    SCK_Pad = 0x1;
    CEN_Pad = 0x1;
    
    
    //400MHz
    ADF4002_Write(0x1FFE93);
    ADF4002_Write(0x1FFE92);
    ADF4002_Write(0x000004);
    ADF4002_Write(0x000A01);
    //1280MHz
    /*  HMC704_ReadA(0x00,&chip1_id);
    HMC704_WriteA(0x01,0x000002);
    HMC704_WriteA(0x02,0x000001);
    HMC704_WriteA(0x09,0x4C0000 | ((60<<7) | 60));
    HMC704_WriteA(0x06,0x0003FA);
    HMC704_WriteA(0x03,0x000020);
    HMC704_WriteA(0x04,0x000000);  //*/
    //800MHz
    HMC704_ReadA(0x00,&chip1_id);
    HMC704_WriteA(0x01,0x000002);
    HMC704_WriteA(0x02,0x000001);
    HMC704_WriteA(0x09,0x4C0000 | ((60<<7) | 60));
    HMC704_WriteA(0x06,0x0003FA);
    HMC704_WriteA(0x03,20); //40*20=800  20150309
    HMC704_WriteA(0x04,0x000000);  //*/
            //1360MHz
            HMC704_ReadB(0x00,&chip2_id);
    HMC704_WriteB(0x01,0x000002);
    HMC704_WriteB(0x02,0x000001);
    HMC704_WriteB(0x09,0x4C0000 | ((60<<7) | 60));
    HMC704_WriteA(0x06,0x0003FA);
    HMC704_WriteB(0x03,0x000022);
    HMC704_WriteB(0x04,0x000000);
    while(1)
    {
        PCA0CPH2 = 0x00;
    }
}

 

宇宙379
关注
专栏目录
hmc830相位噪声_低相位噪声电压控制振荡器(VCO)和稳定基准电压构成的频率合成器...
weixin_39631370的博客
12-20 1314
新兴的PLL + VCO (集成电压控制振荡器的锁相环)技术能够针对蜂窝/4G、微波无线电军事等应用快速开发低相位噪声频率合成器，ADI集成频综产品的频率覆盖为25 MHz到13.6 GHz。蜂窝/4G、微波无线电、测试设备和军事子系统应用的无线电设计人员依赖高质量本振(LO)来实现低BER(误码率)、低杂散输出和低相位噪声的系统级目标。所有的RF和微波通信和传感器系统，无论是基于模拟还是数字调制...
hmc830相位噪声_支持紧凑型LO解决方案，还是靠“PLL VCO”最佳拍档
weixin_30147611的博客
12-29 1229
新兴的PLL + VCO (集成电压控制振荡器的锁相环)技术能够针对蜂窝/4G、微波无线电防务等应用快速开发低相位噪声频率合成器，ADI集成频综产品的频率覆盖为25 MHz到13.6 GHz。蜂窝/4G、微波无线电、测试设备和防务子系统应用的无线电设计人员依赖高质量本振(LO)来实现低BER(误码率)、低杂散输出和低相位噪声的系统级目标。所有的RF和微波通信和传感器系统，无论是基于模拟还是数字调制...
ADF4002手册汉化
04-15
自己汉化的adf4002手册，最后的典型应用部分没汉化，其它部分基本上全汉化了
STM32控制锁相环频综芯片HMC704的程序
09-16
STM32控制锁相环频综芯片HMC704的程序，注释详细，初始化生成一个频率，也可通过串口更改输出的频率，串口部分代码该文件没有。
AD9689+HMC7044调试记录（三）
最新发布
CDLNLG的博客
08-02 1341
新设计的AD9689子卡，采用连接方式，使用Xilinx公司的KCU105开发板进行调试。子卡上主要的芯片是ADI公司的高速模数转换芯片AD9689-2600和时钟芯片HMC7044。HMC7044和AD9689基本配置完成后，开始调试FPGA接收部分。FPGA部分xilinx提供了PG066-JESD204文档。
HMC704初始化.c
05-13
种模式同时上阵，电源稳定后重复发数5次，以确保可靠。一般第一次发数后频率就应该锁定。 #include "C8051F330.h" #define R_DIV 2 //预分频 #define N_DIV 70 //整数分频 #define FRAC 1534506 //小数分频 #define H704_06_REG 0x0B7A//0B7A.小数B模式，需要精确模式，带外好；0B7E.小数A模式，带内好；03FA.整数模式； #define H704_07_REG 0xFA//锁定窗口； #define H704_08_REG 0xC1BEFF//0xC9BEFF前置2分频打开；0xC1BEFF前置2分频关闭； // #define H704_09_REG 0xDFFFFF//鉴相器电流，要仔细设置,要根据仿真计算值设置 #define H704_0B_REG 0x078071//0x078071鉴相器负极性；0x078061鉴相器正极性 #define H704_0C_REG 0x0//，计算后设置,计算公式为 鉴相频率/频率分辨率*外置分频*前置分频 #define H704_0F_REG 0x81//0x81:锁定指示;0xA0正常置1；0x80正常置0.
285.zip_fpga285_fpga配置hmc704_hmc704的FPGA控制程序_hmc704配置程序_频率控制
07-15
用FPGA的IO口来控制频率器件hmc704m
HMC704配置
热门推荐
混沌的博客
05-20 1万+
/* * 主要功能： * * (1)通用I/O模拟实现SPI接口功能 * * (2)鉴相器ADF4002
kaifaban_hmc704.zip_HMC704控制字_hmc704 频率源_hmc704程序设计_单片机 锁相环_频率控制
07-15
使用单片机控制锁相环 hmc704,输出所需频率，
ADF4002-数采板+电路+STM32+STC51,MSP430驱动_V0.2.zip
11-29
STM32和STC51微控制器可能被用来控制ADF4002的工作模式、配置参数以及处理采集到的数据。 **STM32与STC51微控制器** STM32是意法半导体（STMicroelectronics）推出的基于ARM Cortex-M内核的微控制器系列，具备高...
C8051F330单片机FLASH读写操作，以及串口9600波特率收发，等完整工程代码
04-15
C8051F330单片机FLASH读写操作，以及串口9600波特率收发，等完整工程代码，里面有ADF4351,HMC830锁相环代码，射频硬件必备代码。
c8051f330_hmc704.zip_51单片机hmc704_HMC704_hmc704频率_springxog_频率控制
07-14
使用单片机控制锁相环hmc704,输出所需频率，
HMC704LP4E .rar_HMC704_HMC7044用法_PLL 锁相环_hmc_scene2zp
07-14
用于HMC704的测试程序，已验证锁定 工作在HMC模式
hmc704lp4原理图
12-20
这是hmc704lp4的参考原理图，需要的可以参考
hmc704LP4E【翻译狗】.docx
08-24
HMC704LP4自费用翻译狗软件翻译的，翻译程度大概有90%，对英文较差的同学还是值得参考的！勿喷！！！
运用ADF4002 PLL产生高速模数转换器所需的极低抖动编码时钟
01-20
模数转换器即A/D转换器，或简称ADC,通常是指一个将模拟信号转变为数字信号的电子元件。通常的模数转换器是将一个输入电压信号转换为一个输出的数字信号。由于数字信号本身不具有实际意义，仅仅表示一个相对大小。故任何一个模数转换器都需要一个参考模拟量作为转换的标准，比较常见的参考标准为的可转换信号大小。而输出的数字量则表示输入信号相对于参考信号的大小。A/D转换一般要经过采样、保持、量化及编码4个过程。在实际电路中，有些过程是合并进行的，如采样和保持，量化和编码在转换过程中是同时实现的。一般来说，AD比DA贵，尤其是高速的AD,因为在某些特殊场合，如导弹的摄像头部分要求有高速的转换能力。一般那样AD
采用芯片测试的环路滤波器设计
01-20
在给定的配置下，如果将环路带宽设为20kHz并保持50°的相位裕度，VCO的相位噪声会成为主要贡献因素，而芯片本身的噪声则相对较小。 总之，环路滤波器在小数分频频率合成器测试中的设计是至关重要的，它决定了测试...
ADF4002【分频器】（康威）
qq_61533374的博客
04-04 1834
ADF4002【分频器】（康威）
HMC
Paulmin的专栏
10-25 1114
vi usage: http://www.cnblogs.com/ssgblue/archive/2011/08/02/2125123.html install pdsh: http://esgtech.springnote.com/pages/4000893?print=1 http://www.360doc.com/content/11/0216/21/4171006_93645
adf4002怎么当锁相环
08-17
ADF4002是一种高性能的锁相环 (PLL) 控制器。要将ADF4002用作锁相环，您需要按照以下步骤进行配置和操作： 首先，将VCO (Voltage Controlled Oscillator) 连接到ADF4002的控制端。选择一个适当的参考信号源，并通过REFin引脚将其输入到ADF4002的反馈输入端。 接下来，您需要通过SPI (Serial Peripheral Interface) 接口或者并行接口将合适的参数传输给ADF4002。这些参数包括参考频率、VCO的频率范围限制、除数和放大系数等。根据要求，调整这些参数将决定输出频率和锁相环性能。 然后，在ADF4002中选择适当的工作模式。ADF4002可以在整数模式和分数模式之间进行切换。整数模式下，VCO的频率将是参考频率与整数除数的比值。在分数模式下，还将根据附加的分数除数和倍频器进行计算。 使用SPI或并行接口将这些配置参数发送给ADF4002。一旦配置完成，开始锁定过程。 在锁定过程中，ADF4002将通过比较参考信号和VCO输出信号的相位差来调整VCO的频率，直到两者相位差为零。一旦达到锁定状态，ADF4002将持续监测并微调VCO的频率以保持锁相环的稳定性。 最后，您可以通过读取ADF4002的状态寄存器来获取有关锁相环工作状态的信息，例如锁定状态、失锁状态或其他警告标志。 总结而言，将ADF4002用作锁相环涉及到配置参数、选择合适的工作模式和监测锁定状态等步骤。通过正确配置和操作ADF4002，您可以实现所需的锁相环功能。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值