cc1000avr.s

CC1000通信

;   int i;
;   char lock_status;
; 
;   WriteToCC1000Register(CC1000_PA_POW,0x00);   // Turn off PA to avoid frequency splatter
	clr R18
	ldi R16,11
	xcall _WriteToCC1000Register
	.dbline 474
; 
;   WriteToCC1000Register(CC1000_MAIN,0xE1);    // Switch into TX, switch to freq. reg B
	ldi R18,225
	clr R16
	xcall _WriteToCC1000Register
	.dbline 475
;   WriteToCC1000Register(CC1000_PLL,TXPLL);   // Use TX refdiv setting
	mov R18,R22
	ldi R16,12
	xcall _WriteToCC1000Register
	.dbline 476
;   WriteToCC1000Register(CC1000_CURRENT,TXCurrent); // Program VCO current for TX
	mov R18,R20
	ldi R16,9
	xcall _WriteToCC1000Register
	.dbline 479
; 
;   // Wait 250us before monitoring LOCK
;   delaycc(12);
	ldi R16,12
	ldi R17,0
	xcall _delaycc
	.dbline 482
	ldi R20,32766
	ldi R21,127
	xjmp L70
L67:
	.dbline 482
L68:
	.dbline 482
	subi R20,1
	sbci R21,0
L70:
	.dbline 482
; 
;   // Wait for lock
;   for(i=LOCK_TIMEOUT; ((ReadFromCC1000Register(CC1000_LOCK)&0x01)==0)&&(i>0); i--);
	ldi R16,13
	xcall _ReadFromCC1000Register
	sbrc R16,0
	rjmp L71
	clr R2
	clr R3
	cp R2,R20
	cpc R3,R21
	brlt L67
L71:
	.dbline 485
; 
;   // If PLL in lock
;   if ((ReadFromCC1000Register(CC1000_LOCK)&0x01)==0x01){
	ldi R16,13
	xcall _ReadFromCC1000Register
	mov R24,R16
	andi R24,1
	cpi R24,1
	brne L72
	.dbline 485
	.dbline 487
;     // Indicate PLL in LOCK
;     lock_status = LOCK_OK;
	ldi R20,1
	.dbline 489
	xjmp L73
L72:
	.dbline 489
;   // Else (PLL out of LOCK)
;   }else{
	.dbline 491
;     // If recalibration ok
;     if(CalibrateCC1000()){
	xcall _CalibrateCC1000
	tst R16
	breq L74
	.dbline 491
	.dbline 493
;       // Indicate PLL in LOCK
;       lock_status = LOCK_RECAL_OK;
	ldi R20,2
	.dbline 495
	xjmp L75
L74:
	.dbline 495
;     // Else (recalibration failed)
;     }else{
	.dbline 497
;       // Reset frequency syncthesizer (ref.: Errata Note 01)
;       ResetFreqSynth();
	xcall _ResetFreqSynth
	.dbline 499
;       // Indicate PLL out of LOCK
;       lock_status = LOCK_NOK;
	clr R20
	.dbline 500
;     }
L75:
	.dbline 501
;   }
L73:
	.dbline 504
; 
;   // Increase output power
;   WriteToCC1000Register(CC1000_PA_POW,PA_VALUE); // Restore PA setting
	ldi R18,240
	ldi R16,11
	xcall _WriteToCC1000Register
	.dbline 507
;   
;   // Return LOCK status to application
;   return (lock_status);
	mov R16,R20
	.dbline -2
L66:
	xcall pop_gset2
	.dbline 0 ; func end
	ret
	.dbsym r lock_status 20 c
	.dbsym r i 20 I
	.dbsym r TXPLL 22 c
	.dbsym r TXCurrent 20 c
	.dbend
	.dbfunc e SetupCC1000PD _SetupCC1000PD fV
	.even
_SetupCC1000PD::
	.dbline -1
	.dbline 517
; }
; 
; /****************************************************************************/
; /*  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)
; {
	.dbline 518
;   WriteToCC1000Register(CC1000_MAIN,0x3F);    // Put CC1000 into power-down
	ldi R18,63
	clr R16
	xcall _WriteToCC1000Register
	.dbline 519
;   WriteToCC1000Register(CC1000_PA_POW,0x00);  // Turn off PA to minimise current draw
	clr R18
	ldi R16,11
	xcall _WriteToCC1000Register
	.dbline -2
L76:
	.dbline 0 ; func end
	ret
	.dbend
	.dbfunc e WakeUpCC1000ToRX _WakeUpCC1000ToRX fV
;              i -> <dead>
;          RXPLL -> R20
;      RXCurrent -> R22
	.even
_WakeUpCC1000ToRX::
	xcall push_gset2
	mov R20,R18
	mov R22,R16
	.dbline -1
	.dbline 528
; }
; 
; /****************************************************************************/
; /*  This routine wakes the CC1000 up from PD mode to RX mode, call          */
; /*  SetupCC1000RX after this routine is finished.                           */
; /****************************************************************************/
; 
; void WakeUpCC1000ToRX(char RXCurrent,char RXPLL)
; {
	.dbline 532
;   int i;
;   
;   
;   WriteToCC1000Register(CC1000_MAIN,0x3B);  // Turn on xtal oscillator core
	ldi R18,59
	clr R16
	xcall _WriteToCC1000Register
	.dbline 533
;   WriteToCC1000Register(CC1000_CURRENT,RXCurrent); // Program VCO current for RX 
	mov R18,R22
	ldi R16,9
	xcall _WriteToCC1000Register
	.dbline 534
;   WriteToCC1000Register(CC1000_PLL,RXPLL); // Use RX refdiv setting
	mov R18,R20
	ldi R16,12
	xcall _WriteToCC1000Register
	.dbline 538
;   
;   // Insert wait routine here, must wait for xtal oscillator to stabilise, 
;   // typically takes 2-5ms.
;   delaycc(38);   //35 is 2ms
	ldi R16,38
	ldi R17,0
	xcall _delaycc
	.dbline 540
;   
;   WriteToCC1000Register(CC1000_MAIN,0x39);  // Turn on bias generator
	ldi R18,57
	clr R16
	xcall _WriteToCC1000Register
	.dbline 542
;   // Wait for 250us, insert wait loop here
;   delaycc(12);
	ldi R16,12
	ldi R17,0
	xcall _delaycc
	.dbline 543
;   WriteToCC1000Register(CC1000_MAIN,0x31);  // Turn on frequency synthesiser
	ldi R18,49
	clr R16
	xcall _WriteToCC1000Register
	.dbline -2
L77:
	xcall pop_gset2
	.dbline 0 ; func end
	ret
	.dbsym l i 1 I
	.dbsym r RXPLL 20 c
	.dbsym r RXCurrent 22 c
	.dbend
	.dbfunc e WakeUpCC1000ToTX _WakeUpCC1000ToTX fV
;              i -> <dead>
;          TXPLL -> R20
;      TXCurrent -> R22
	.even
_WakeUpCC1000ToTX::
	xcall push_gset2
	mov R20,R18
	mov R22,R16
	.dbline -1
	.dbline 552
; }
; 
; /****************************************************************************/
; /*  This routine wakes the CC1000 up from PD mode to TX mode, call          */
; /*  SetupCC1000TX after this routine is finished.                           */
; /****************************************************************************/
; 
; void WakeUpCC1000ToTX(char TXCurrent,char TXPLL)
; {
	.dbline 556
;   int i;
;   
;   
;   WriteToCC1000Register(CC1000_MAIN,0xFB);  // Turn on xtal oscillator core
	ldi R18,251
	clr R16
	xcall _WriteToCC1000Register
	.dbline 557
;   WriteToCC1000Register(CC1000_CURRENT,TXCurrent); // Program VCO current for TX
	mov R18,R22
	ldi R16,9
	xcall _WriteToCC1000Register
	.dbline 558
;   WriteToCC1000Register(CC1000_PLL,TXPLL); // Use TX refdiv setting
	mov R18,R20
	ldi R16,12
	xcall _WriteToCC1000Register
	.dbline 562
;   
;   // Insert wait routine here, must wait for xtal oscillator to stabilise, 
;   // typically takes 2-5ms. 
;   delaycc(38);   //35 is 2ms
	ldi R16,38
	ldi R17,0
	xcall _delaycc
	.dbline 564
;   
;   WriteToCC1000Register(CC1000_MAIN,0xF9);  // Turn on bias generator
	ldi R18,249
	clr R16
	xcall _WriteToCC1000Register
	.dbline 566
;   // Wait for 250us, insert wait loop here
;   delaycc(12);
	ldi R16,12
	ldi R17,0
	xcall _delaycc
	.dbline 567
;   WriteToCC1000Register(CC1000_PA_POW,PA_VALUE); // Turn on PA
	ldi R18,240
	ldi R16,11
	xcall _WriteToCC1000Register
	.dbline 568
;   WriteToCC1000Register(CC1000_MAIN,0xF1);  // Turn on frequency synthesiser
	ldi R18,241
	clr R16
	xcall _WriteToCC1000Register
	.dbline -2
L78:
	xcall pop_gset2
	.dbline 0 ; func end
	ret
	.dbsym l i 1 I
	.dbsym r TXPLL 20 c
	.dbsym r TXCurrent 22 c
	.dbend
	.dbfunc e AverageManualLockCC1000 _AverageManualLockCC1000 fV
	.even
_AverageManualLockCC1000::
	.dbline -1
	.dbline 576
; }
; 
; /****************************************************************************/
; /*  This routine locks the averaging filter of the CC1000                   */
; /****************************************************************************/
; 
; void AverageManualLockCC1000(void)
; {
	.dbline 577
;   WriteToCC1000Register(CC1000_MODEM1,0x1D);//0x19
	ldi R18,29
	ldi R16,16
	xcall _WriteToCC1000Register
	.dbline -2
L79:
	.dbline 0 ; func end
	ret
	.dbend
	.dbfunc e AverageFreeRunCC1000 _AverageFreeRunCC1000 fV
	.even
_AverageFreeRunCC1000::
	.dbline -1
	.dbline 585
; }
; 
; /****************************************************************************/
; /*  This routine unlocks the averaging filter of the CC1000                 */
; /****************************************************************************/
; 
; void AverageFreeRunCC1000(void)
; {
	.dbline 586
;   WriteToCC1000Register(CC1000_MODEM1,0x09);
	ldi R18,9
	ldi R16,16
	xcall _WriteToCC1000Register
	.dbline -2
L80:
	.dbline 0 ; func end
	ret
	.dbend
	.dbfunc e AverageAutoLockCC1000 _AverageAutoLockCC1000 fV
	.even
_AverageAutoLockCC1000::
	.dbline -1
	.dbline 595
; }
; 
; /****************************************************************************/
; /*  This routine sets up the averaging filter of the CC1000 for automatic   */
; /*  lock. This can be used in polled receivers.                             */
; /****************************************************************************/
; 
; void AverageAutoLockCC1000(void)
; {
	.dbline 596
;   WriteToCC1000Register(CC1000_MODEM1,0x01);
	ldi R18,1
	ldi R16,16
	xcall _WriteToCC1000Register
	.dbline -2
L81:
	.dbline 0 ; func end
	ret
	.dbend
	.dbfunc e ReadCurrentCalibration _ReadCurrentCalibration fV
;           val2 -> R20,R21
;           val1 -> R22,R23
	.even
_ReadCurrentCalibration::
	xcall push_gset2
	movw R20,R18
	movw R22,R16
	.dbline -1
	.dbline 604
; }
; 
; /****************************************************************************/
; /*  This routine reads the current calibration values from the CC1000       */
; /****************************************************************************/
; 
; void ReadCurrentCalibration(char *val1, char *val2)
; {
	.dbline 605
;   *val1=ReadFromCC1000Register(CC1000_TEST0);
	ldi R16,70
	xcall _ReadFromCC1000Register
	movw R30,R22
	std z+0,R16
	.dbline 606
;   *val2=ReadFromCC1000Register(CC1000_TEST2);
	ldi R16,68
	xcall _ReadFromCC1000Register
	movw R30,R20
	std z+0,R16
	.dbline -2
L82:
	xcall pop_gset2
	.dbline 0 ; func end
	ret
	.dbsym r val2 20 pc
	.dbsym r val1 22 pc
	.dbend
	.dbfunc e OverrideCurrentCalibration _OverrideCurrentCalibration fV
;           val2 -> R20
;           val1 -> R22
	.even
_OverrideCurrentCalibration::
	xcall push_gset2
	mov R20,R18
	mov R22,R16
	.dbline -1
	.dbline 614
; }
; 
; /****************************************************************************/
; /*  This routine overrides the current calibration of the CC1000            */
; /****************************************************************************/
; 
; void OverrideCurrentCalibration(char val1, char val2)
; {
	.dbline 615
;   WriteToCC1000Register(CC1000_TEST5,(val1&0x0F)|0x10);
	mov R18,R22
	andi R18,15
	ori R18,16
	ldi R16,65
	xcall _WriteToCC1000Register
	.dbline 616
;   WriteToCC1000Register(CC1000_TEST6,(val2&0x1F)|0x20);
	mov R18,R20
	andi R18,31
	ori R18,32
	ldi R16,64
	xcall _WriteToCC1000Register
	.dbline -2
L83:
	xcall pop_gset2
	.dbline 0 ; func end
	ret
	.dbsym r val2 20 c
	.dbsym r val1 22 c
	.dbend
	.dbfunc e StopOverridingCalibration _StopOverridingCalibration fV
	.even
_StopOverridingCalibration::
	.dbline -1
	.dbline 624
; }
; 
; /****************************************************************************/
; /*  This routine stops override of the CC1000 calibration values            */
; /****************************************************************************/
; 
; void StopOverridingCalibration(void)
; {
	.dbline 625
;   WriteToCC1000Register(CC1000_TEST5,0x00);
	clr R18
	ldi R16,65
	xcall _WriteToCC1000Register
	.dbline 626
;   WriteToCC1000Register(CC1000_TEST6,0x00);
	clr R18
	ldi R16,64
	xcall _WriteToCC1000Register
	.dbline -2
L84:
	.dbline 0 ; func end
	ret
	.dbend
	.dbfunc e ResetFreqSynth _ResetFreqSynth fV
;   modem1_value -> R20
	.even
_ResetFreqSynth::
	xcall push_gset1
	.dbline -1
	.dbline 634
; }
;   
; 
; /****************************************************************************/
; /*  This CC1000 frequency synthesizer                                       */
; /****************************************************************************/
; void ResetFreqSynth(void)
; {
	.dbline 636
;   char modem1_value;
;   modem1_value = ReadFromCC1000Register(CC1000_MODEM1)&~0x01;
	ldi R16,16
	xcall _ReadFromCC1000Register
	mov R20,R16
	andi R20,254
	.dbline 637
;   WriteToCC1000Register(CC1000_MODEM1,modem1_value);
	mov R18,R20
	ldi R16,16
	xcall _WriteToCC1000Register
	.dbline 638
;   WriteToCC1000Register(CC1000_MODEM1,modem1_value|0x01);
	mov R18,R20
	ori R18,1
	ldi R16,16
	xcall _WriteToCC1000Register
	.dbline -2
L85:
	xcall pop_gset1
	.dbline 0 ; func end
	ret
	.dbsym r modem1_value 20 c
	.dbend