cc1000_rar cc1000main_c.htm

asm source code asm source code asm source code asm source code

    o_pale=1; 
   
    byun.Data=addr<<1; 
    o_pale=0; 
     
    // Send address bits 
    for (BitCounter=0;BitCounter<7;BitCounter++) 
    { 
        o_pclk=1; 
        o_pdata=byun.B.MSB; 
        byun.Data=byun.Data<<1; 
        o_pclk=0; 
    } 
     
    // Send read/write bit , Ignore bit in data, always use 0  
    o_pclk=1; 
    o_pdata=0; 
    o_pclk=0; 
  
    o_pclk=1; 
    o_pale=1; 
     
    // Receive data bits  
    o_pdata=1; 
    
    TRISA |= 0B00000100; // Set up o_pdata(RA2) as an input 
     
    for (BitCounter=0;BitCounter<8;BitCounter++) 
    { 
        o_pclk=0; 
        byun.Data=byun.Data<<1; 
        byun.B.LSB=o_pdata; 
        o_pclk=1; 
    } 
   
    TRISA &= 0B11111011; // Set up o_pdata(RA2) as an output again 
   
    return byun.Data; 
} 
 
 
   
//=========================================================================== 
//= This routine resets the CC1000, clearing all registers.                 = 
//=========================================================================== 
void ResetCC1000(void) 
{ 
  INT8U MainValue; 
   
  MainValue=ReadFromCC1000Register(CC1000_MAIN); 
  WriteToCC1000Register(CC1000_MAIN, MainValue&0xFE); // Reset CC1000 
  WriteToCC1000Register(CC1000_MAIN, MainValue|0x01); // Bring CC1000 out of reset 
} 
 
 
//=========================================================================== 
//= This routine calibrates the CC1000                                      = 
//= Returns 0 if calibration fails, non-zero otherwise. Checks the LOCK     = 
//= to check for success.                                                   = 
//=========================================================================== 
 
INT8U CalibrateCC1000(void) 
{ 
    INT8U TimeOutCounter; 
 
    WriteToCC1000Register(CC1000_PA_POW,0x00);  // Turn off PA to avoid spurs 
                                                // during calibration in TX mode 
    WriteToCC1000Register(CC1000_CAL,0xA6);     // Start calibration 
   
    // Wait for calibration complete 
    for(TimeOutCounter=CAL_TIMEOUT; ((ReadFromCC1000Register(CC1000_CAL)&0x08)==0)&&(TimeOutCounter>0); TimeOutCounter--); 
 
    WriteToCC1000Register(CC1000_CAL,0x26); /* End calibration */ 
    WriteToCC1000Register(CC1000_PA_POW,PA_VALUE); /* Restore PA setting */ 
 
    // Wait for lock 
    for(TimeOutCounter=LOCK_TIMEOUT; ((ReadFromCC1000Register(CC1000_LOCK)&0x01)==0)&&(TimeOutCounter>0); TimeOutCounter--); 
 
    return ((ReadFromCC1000Register(CC1000_LOCK)&0x01)==1); 
} 
 
 
//=========================================================================== 
//= This routine puts the CC1000 into RX mode (from TX). When switching to  = 
//= RX from PD, use WakeupC1000ToRX first                                   = 
//=========================================================================== 
INT8U SetupCC1000RX(INT8U RXCurrent) 
{ 
    INT16U i; 
    INT8U  lock_status; 
 
    WriteToCC1000Register(CC1000_MAIN,0x11);    // Switch into RX, switch to freq. reg A 
    WriteToCC1000Register(CC1000_PLL,RXPLL);         // Use RX refdiv setting 
    WriteToCC1000Register(CC1000_CURRENT,RXCurrent); // Program VCO current for RX 
 
    // Wait for 250us before monitoring LOCK 
    for (i=0;i<25;i++); 
 
     
    // Wait for lock 
    for(i=LOCK_TIMEOUT; ((ReadFromCC1000Register(CC1000_LOCK)&0x01)==0)&&(i>0); i--); 
 
    // If PLL in lock 
    if ((ReadFromCC1000Register(CC1000_LOCK)&0x01)==0x01) 
    { 
        // Indicate PLL in LOCK 
        lock_status = LOCK_OK; 
    } 
    else 
    {   // Else (PLL out of LOCK) 
         
        if(CalibrateCC1000()) 
        {   // If recalibration ok 
            lock_status = LOCK_RECAL_OK; // Indicate PLL in LOCK 
        } 
        else 
        {   // Else (recalibration failed) 
            // Reset frequency syncthesizer (ref.: Errata Note 01) 
            ResetFreqSynth(); 
            // Indicate PLL out of LOCK 
            lock_status = LOCK_NOK; 
        } 
    } 
     
     
    // Return LOCK status to application 
    return (lock_status); 
} 
 
 
 
//=========================================================================== 
//= This routine puts the CC1000 into TX mode (from RX). When switching to  = 
//= TX from PD, use WakeupCC1000ToTX first                                  = 
//=========================================================================== 
INT8U SetupCC1000TX(INT8U TXCurrent) 
{ 
    INT16U i; 
    INT8U lock_status; 
 
    WriteToCC1000Register(CC1000_PA_POW,0x00);       // Turn off PA to avoid frequency splatter 
 
    WriteToCC1000Register(CC1000_MAIN,0xE1);         // Switch into TX, switch to freq. reg B 
    WriteToCC1000Register(CC1000_PLL,TXPLL);         // Use TX refdiv setting 
    WriteToCC1000Register(CC1000_CURRENT,TXCurrent); // Program VCO current for TX 
 
    // Wait for 250us before monitoring LOCK 
    for (i=0;i<25;i++); 
  
    // Wait for lock 
    for(i=LOCK_TIMEOUT; ((ReadFromCC1000Register(CC1000_LOCK)&0x01)==0x00)&&(i>0); i--); 
 
    // If PLL in lock 
    if ((ReadFromCC1000Register(CC1000_LOCK)&0x01)==0x01) 
    { 
        // Indicate PLL in LOCK 
        lock_status = LOCK_OK; 
    } 
    else 
    {   // Else (PLL out of LOCK) 
        // If recalibration ok 
        if(CalibrateCC1000()) 
        { 
            // Indicate PLL in LOCK 
            lock_status = LOCK_RECAL_OK; 
        } 
        else 
        {   // Else (recalibration failed) 
            // Reset frequency syncthesizer (ref.: Errata Note 01) 
            ResetFreqSynth(); 
            // Indicate PLL out of LOCK 
            lock_status = LOCK_NOK; 
        } 
    } 
 
    // Increase output power 
    WriteToCC1000Register(CC1000_PA_POW,PA_VALUE); // Restore PA setting 
 
    // Return LOCK status to application 
    return (lock_status); 
} 
 
 
 
//=========================================================================== 
//= This routine puts the CC1000 into power down mode. Use WakeUpCC1000ToRX = 
//= followed by SetupCC1000RX or WakeupCC1000ToTX followed by SetupCC1000TX = 
//= to wake up from power down                                              = 
//=========================================================================== 
void SetupCC1000PD(void) 
{ 
    WriteToCC1000Register(CC1000_MAIN,0x3F);    // Put CC1000 into power-down 
    WriteToCC1000Register(CC1000_PA_POW,0x00);  // Turn off PA to minimise current draw 
} 
 
 
//=========================================================================== 
//= This routine wakes the CC1000 up from PD mode to RX mode, call          = 
//= SetupCC1000RX after this routine is finished.                           = 
//=========================================================================== 
void WakeUpCC1000ToRX(INT8U RXCurrent) 
{ 
    INT16U i; 
   
    WriteToCC1000Register(CC1000_MAIN,0x3B);  // Turn on xtal oscillator core 
    WriteToCC1000Register(CC1000_CURRENT,RXCurrent); // Program VCO current for RX  
    WriteToCC1000Register(CC1000_PLL,RXPLL); // Use RX refdiv setting 
   
    // Insert wait routine here, must wait for xtal oscillator to stabilise,  
    // typically takes 2-5ms. 
    for (i=0;i<450;i++); 
   
    WriteToCC1000Register(CC1000_MAIN,0x39);  // Turn on bias generator 
    // Wait for 250us, insert wait loop here 
    for (i=0;i<25;i++); 
    WriteToCC1000Register(CC1000_MAIN,0x31);  // Turn on frequency synthesiser 
} 
 
 
 
//=========================================================================== 
//= This routine wakes the CC1000 up from PD mode to TX mode, call          = 
//= SetupCC1000TX after this routine is finished.                           = 
//=========================================================================== 
void WakeUpCC1000ToTX(INT8U TXCurrent) 
{ 
    INT16U i; 
 
    WriteToCC1000Register(CC1000_MAIN,0xFB);  // Turn on xtal oscillator core 
    WriteToCC1000Register(CC1000_CURRENT,TXCurrent); // Program VCO current for TX 
    WriteToCC1000Register(CC1000_PLL,TXPLL); // Use TX refdiv setting 
   
    // Insert wait routine here, must wait for xtal oscillator to stabilise,  
    // typically takes 2-5ms.  
    for (i=0;i<450;i++); 
   
    WriteToCC1000Register(CC1000_MAIN,0xF9);  // Turn on bias generator 
    // Wait for 250us, insert wait loop here 
    for (i=0;i<25;i++); 
    WriteToCC1000Register(CC1000_PA_POW,PA_VALUE); // Turn on PA 
    WriteToCC1000Register(CC1000_MAIN,0xF1);  // Turn on frequency synthesiser 
} 
 
/****************************************************************************/ 
/*  This routine locks the averaging filter of the CC1000                   */ 
/****************************************************************************/ 
void AverageManualLockCC1000(void) 
{ 
    WriteToCC1000Register(CC1000_MODEM1,0x79); //0x19 
} 
 
/****************************************************************************/ 
/*  This routine unlocks the averaging filter of the CC1000                 */ 
/****************************************************************************/ 
void AverageFreeRunCC1000(void) 
{ 
    WriteToCC1000Register(CC1000_MODEM1,0x69); //0x09 
} 
 
/****************************************************************************/ 
/*  This routine sets up the averaging filter of the CC1000 for automatic   */ 
/*  lock. This can be used in polled receivers.                             */ 
/****************************************************************************/ 
void AverageAutoLockCC1000(void) 
{ 
    WriteToCC1000Register(CC1000_MODEM1,0x01); 
} 
 
 
//=========================================================================== 
//= This routine resets the CC1000 frequency synthesizer                    = 
//=========================================================================== 
void ResetFreqSynth(void) 
{ 
    INT8U modem1_value; 
    modem1_value = ReadFromCC1000Register(CC1000_MODEM1)&~0x01; 
    WriteToCC1000Register(CC1000_MODEM1,modem1_value); 
    WriteToCC1000Register(CC1000_MODEM1,modem1_value|0x01); 
} 
 
 
 
//=========================================================================== 
//= CC1000初始化            	  			                                = 
//=========================================================================== 
void CC1000Init(void) 
{ 
    SetupCC1000PD(); 
    ResetCC1000(); 
    SetupCC1000All(); 
    WakeUpCC1000ToRX(RXDL); 
    SetupCC1000TX(TXDL);   
    CalibrateCC1000();              	 
    SetupCC1000RX(RXDL); 
    CalibrateCC1000(); 
  
    //现在CC1000接收和发送均已被校准,我们不再需要重新 
    //校准,除非频率改变或温度改变超过40度或电源电压改变超过0.5V 
} 
 
 
 
/**************************************************************************/ 
/*  设置所有的CC1000寄存器         					                      */ 
/*************************************************************************/ 
void SetupCC1000All(void) 
{  
    INT8U counter; 
    INT8U value; 
   
    for (counter=CC1000_FREQ_2A; counter <= CC1000_PRESCALER; counter++)  
    { 
        if (counter == CC1000_MODEM0) 
        { 
            if (b_Mcode == YES) value = 0x27;	// 2.4kBaud Mcode 
            if (b_NRZ   == YES) value = 0x23;	// 2.4kBaud NRZ 
            if (b_UART  == YES) value = 0x2B; 	// 2.4kBaud UART 
        } 
        else 
        { 
            value=DefaultConfig[counter-1]; 
        } 
        WriteToCC1000Register(counter,value); 
    } 
     
    for (counter = CC1000_TEST6; counter <= CC1000_TEST0; counter++) 
    { 
        value=DefaultConfig[counter - CC1000_TEST6 + CC1000_PRESCALER]; 
        WriteToCC1000Register(counter,value); 
    } 
} 
 
</PRE>
<SCRIPT src="CC1000_rar CC1000Main_c_files/gg_read2.js"></SCRIPT>
<BR>
<SCRIPT language=JavaScript src="CC1000_rar CC1000Main_c_files/stat.htm" 
charset=gb2312></SCRIPT>
</BODY></HTML>