📄 uart.s
字号:
ldi R24,2
out 0x17,R24
ldi R24,8
mov R10,R24
rjmp L147
L144:
; for(tmp=8;tmp>0;tmp--){
; itmp =itmp <<1;
lsl R12
; Pclk_0;
cbi 0x18,1
; delay(10);
ldi R16,10
ldi R17,0
ldi R18,0
ldi R19,0
rcall _delay
; if(PData == 1) itmp= itmp+1;
in R24,0x18
andi R24,1
out 0x18,R24
cpi R24,1
brne L148
inc R12
L148:
sbi 0x18,1
ldi R16,10
ldi R17,0
ldi R18,0
ldi R19,0
rcall _delay
L145:
dec R10
L147:
clr R2
cp R2,R10
brlo L144
; Pclk_1;
; delay(10);
; }
; Pclk_0;
cbi 0x18,1
; PSEL_1;
sbi 0x12,5
; // P2MDOUT = 0xA0;
; DDRD = 0x30;
ldi R24,48
out 0x11,R24
; DDRB = 0X03;
ldi R24,3
out 0x17,R24
; return(itmp);
mov R16,R12
L137:
rcall pop_gset4
.dbline 0 ; func end
ret
; tmp -> R10
; itmp -> R12
; value -> R14
; addr -> y+10
.even
_WriteToCC1020Register::
rcall push_arg4
rcall push_gset5
mov R14,R18
; }
;
;
; /****************************************************************************/
; /* This routine writes to a single CC1020 register */
; /****************************************************************************/
; void WriteToCC1020Register(unsigned char addr, unsigned char value)
; {
; unsigned char itmp = 0;
clr R12
; unsigned char tmp=0;;
clr R10
; // P2MDOUT = 0xE0;
; DDRD = 0x30;
ldi R24,48
out 0x11,R24
; DDRB = 0X03;
ldi R24,3
out 0x17,R24
; delay(10);
ldi R16,10
ldi R17,0
ldi R18,0
ldi R19,0
rcall _delay
; PSEL_0;
cbi 0x12,5
; itmp = (addr&0x7f) <<1;
ldd R24,y+10
andi R24,127
mov R12,R24
lsl R12
; itmp = itmp+1;
inc R12
ldi R24,8
mov R10,R24
rjmp L154
L151:
; for(tmp=8;tmp>0;tmp--){
; Pclk_0;
cbi 0x18,1
; if((itmp&0x80) == 0x80) PData_1;
mov R24,R12
andi R24,128
cpi R24,128
brne L155
sbi 0x18,0
rjmp L156
L155:
; else PData_0;
cbi 0x18,0
L156:
ldi R16,10
ldi R17,0
ldi R18,0
ldi R19,0
rcall _delay
sbi 0x18,1
ldi R16,10
ldi R17,0
ldi R18,0
ldi R19,0
rcall _delay
lsl R12
L152:
dec R10
L154:
clr R2
cp R2,R10
brlo L151
; delay(10);
; Pclk_1;
; delay(10);
; itmp = itmp<<1;
; }
;
; itmp = value;
mov R12,R14
ldi R24,8
mov R10,R24
rjmp L160
L157:
; for(tmp=8;tmp>0;tmp--){
; Pclk_0;
cbi 0x18,1
; if((itmp&0x80) == 0x80) PData_1;
mov R24,R12
andi R24,128
cpi R24,128
brne L161
sbi 0x18,0
rjmp L162
L161:
; else PData_0;
cbi 0x18,0
L162:
ldi R16,10
ldi R17,0
ldi R18,0
ldi R19,0
rcall _delay
sbi 0x18,1
ldi R16,10
ldi R17,0
ldi R18,0
ldi R19,0
rcall _delay
lsl R12
L158:
dec R10
L160:
clr R2
cp R2,R10
brlo L157
; delay(10);
; Pclk_1;
; delay(10);
; itmp = itmp<<1;
; }
; Pclk_0;
cbi 0x18,1
; PSEL_1;
sbi 0x12,5
; // P2MDOUT = 0xA0;
; DDRD = 0x30;
ldi R24,48
out 0x11,R24
; DDRB = 0X03;
ldi R24,3
out 0x17,R24
L150:
rcall pop_gset5
adiw R28,4
.dbline 0 ; func end
ret
.even
_SetupAGC::
; }
;
; void SetupAGC(void)
; {
; // int RSSI1,RSSI2;
; // unsigned char vga;
; WriteToCC1020Register(CC1020_VGA2,0xbf); //disable agc LNA2gain maximun
ldi R18,191
ldi R16,18
rcall _WriteToCC1020Register
; WriteToCC1020Register(CC1020_VGA3,0x20); //vga_setting=0
ldi R18,32
ldi R16,19
rcall _WriteToCC1020Register
;
; //test rssi
; /* for(int i=0x0300;i>0;i--);
; RSSI1=ReadRSSIlevelCC1020()*4;
; for( vga=0;vga<31;vga++)
; {
; //WriteToCC1020Register(CC1020_VGA3,(0x20+vga)); //vga_setting=vga
; RSSI2=ReadRSSIlevelCC1020();
; if(RSSI2>RSSI1) break;
; } */
;
; //vga_setting=vga
; WriteToCC1020Register(CC1020_VGA3,(0x20+15));
ldi R18,47
ldi R16,19
rcall _WriteToCC1020Register
; //enable agc
; WriteToCC1020Register(CC1020_VGA2,0x55);
ldi R18,85
ldi R16,18
rcall _WriteToCC1020Register
; //set cs_level
; WriteToCC1020Register(CC1020_VGA4,0x20+25);
ldi R18,57
ldi R16,20
rcall _WriteToCC1020Register
L163:
.dbline 0 ; func end
ret
; i -> y+0
; RXANALOG -> R20
.even
_WakeUpCC1020ToRX::
rcall push_gset1
mov R20,R16
sbiw R28,2
; // _NOP();
; }
;
; /****************************************************************************/
; /* This routine wakes the CC1020 up from PD mode to RX mode */
; /****************************************************************************/
;
; void WakeUpCC1020ToRX(unsigned char RXANALOG)
; {
; volatile int i;
;
; // Turn on xtal oscillator core
; WriteToCC1020Register(CC1020_MAIN,0x1B);
ldi R18,27
clr R16
rcall _WriteToCC1020Register
;
; // Setup bias current adjustment
; WriteToCC1020Register(CC1020_ANALOG,RXANALOG);
mov R18,R20
ldi R16,23
rcall _WriteToCC1020Register
ldi R24,16992
ldi R25,66
std y+1,R25
std y+0,R24
L165:
L166:
;
; // Insert wait routine here, must wait for xtal oscillator to stabilise,
; // typically takes 2-5ms.
; for (i=0x4260; i > 0; i--);
ldd R24,y+0
ldd R25,y+1
sbiw R24,1
std y+1,R25
std y+0,R24
clr R2
clr R3
cp R2,R24
cpc R3,R25
brlt L165
;
; // Turn on bias generator
; WriteToCC1020Register(CC1020_MAIN,0x19);
ldi R18,25
clr R16
rcall _WriteToCC1020Register
ldi R24,528
ldi R25,2
std y+1,R25
std y+0,R24
L169:
L170:
;
; // Wait for 150 usec
; for (i=0x0210; i > 0; i--);
ldd R24,y+0
ldd R25,y+1
sbiw R24,1
std y+1,R25
std y+0,R24
clr R2
clr R3
cp R2,R24
cpc R3,R25
brlt L169
;
; // Turn on frequency synthesiser
; WriteToCC1020Register(CC1020_MAIN,0x11);
ldi R18,17
clr R16
rcall _WriteToCC1020Register
L164:
adiw R28,2
rcall pop_gset1
.dbline 0 ; func end
ret
; i -> y+0
; TXANALOG -> R10
.even
_WakeUpCC1020ToTX::
rcall push_gset3
mov R10,R16
sbiw R28,2
;
; }
;
; /****************************************************************************/
; /* This routine wakes the CC1020 up from PD mode to TX mode */
; /****************************************************************************/
;
; void WakeUpCC1020ToTX(unsigned char TXANALOG)
; {
; volatile int i;
;
; // Turn on xtal oscillator core
; WriteToCC1020Register(CC1020_MAIN,0xDB);
ldi R18,219
clr R16
rcall _WriteToCC1020Register
;
; // Setup bias current adjustment
; WriteToCC1020Register(CC1020_ANALOG,TXANALOG);
mov R18,R10
ldi R16,23
rcall _WriteToCC1020Register
ldi R20,0
ldi R21,38
ldi R22,4
ldi R23,0
movw R2,R20
std y+1,R3
std y+0,R2
rjmp L177
L174:
L175:
ldd R24,y+0
ldd R25,y+1
sbiw R24,1
std y+1,R25
std y+0,R24
L177:
;
; // Insert wait routine here, must wait for xtal oscillator to stabilise,
; // typically takes 2-5ms.
; for (i=0x42600; i > 0; i--);
clr R2
clr R3
ldd R4,y+0
ldd R5,y+1
cp R2,R4
cpc R3,R5
brlt L174
;
; // Turn on bias generator
; WriteToCC1020Register(CC1020_MAIN,0xD9);
ldi R18,217
clr R16
rcall _WriteToCC1020Register
ldi R24,8448
ldi R25,33
std y+1,R25
std y+0,R24
L178:
L179:
;
; // Wait for 150 usec
; for (i=0x02100; i > 0; i--);
ldd R24,y+0
ldd R25,y+1
sbiw R24,1
std y+1,R25
std y+0,R24
clr R2
clr R3
cp R2,R24
cpc R3,R25
brlt L178
;
; // Turn on frequency synthesiser
; WriteToCC1020Register(CC1020_MAIN,0xD1);
ldi R18,209
clr R16
rcall _WriteToCC1020Register
L173:
adiw R28,2
rcall pop_gset3
.dbline 0 ; func end
ret
; nCalAttempt -> y+2
; TimeOutCounter -> y+0
; PA_POWER -> R20
.even
_CalibrateCC1020::
rcall push_gset1
mov R20,R16
sbiw R28,4
;
; }
;
; /****************************************************************************/
; /* This routine calibrates the CC1020 */
; /* Returns 0 if calibration fails, non-zero otherwise. Checks the LOCK */
; /* to check for success. */
; /****************************************************************************/
;
; char CalibrateCC1020(unsigned char PA_POWER)
; {
; volatile int TimeOutCounter;
; volatile int nCalAttempt;
;
; // Turn off PA to avoid spurs during calibration in TX mode
; WriteToCC1020Register(CC1020_PA_POWER,0x00);
clr R18
ldi R16,28
rcall _WriteToCC1020Register
;
; // Calibrate, and re-calibrate if necessary:
; for (nCalAttempt = CAL_ATTEMPT_MAX; nCalAttempt>0; nCalAttempt--)
ldi R24,4
ldi R25,0
std y+3,R25
std y+2,R24
L183:
; {
;
; // Start calibration
; WriteToCC1020Register(CC1020_CALIBRATE,0xB4);
ldi R18,180
ldi R16,27
rcall _WriteToCC1020Register
;
; // Monitor actual calibration start (ref. Errata Note 04 - CC1020)
; for(TimeOutCounter=CAL_TIMEOUT; TimeOutCounter>0; TimeOutCounter--)
ldi R24,32766
ldi R25,127
std y+1,R25
std y+0,R24
L187:
; {
; if((ReadFromCC1020Register(CC1020_STATUS)&0x80)==0x00) break;
ldi R16,64
rcall _ReadFromCC1020Register
sbrc R16,7
rjmp L191
rjmp L189
L191:
L188:
ldd R24,y+0
ldd R25,y+1
sbiw R24,1
std y+1,R25
std y+0,R24
clr R2
clr R3
cp R2,R24
cpc R3,R25
brlt L187
L189:
; }
;
; // Monitor calibration complete
; // for(TimeOutCounter=CAL_TIMEOUT; ((ReadFromCC1020Register(CC1020_STATUS)&0x80)==0x00)&&(TimeOutCounter>0); TimeOutCounter--);
; for(TimeOutCounter=CAL_TIMEOUT; TimeOutCounter>0; TimeOutCounter--)
ldi R24,32766
ldi R25,127
std y+1,R25
std y+0,R24
L193:
; {
; if((ReadFromCC1020Register(CC1020_STATUS)&0x80)==0x80) break;
ldi R16,64
rcall _ReadFromCC1020Register
mov R24,R16
andi R24,128
cpi R24,128
brne L197
rjmp L195
L197:
L194:
ldd R24,y+0
ldd R25,y+1
sbiw R24,1
std y+1,R25
std y+0,R24
clr R2
clr R3
cp R2,R24
cpc R3,R25
brlt L193
L195:
; }
; // Monitor lock
; for(TimeOutCounter=LOCK_TIMEOUT; TimeOutCounter>0; TimeOutCounter--)
ldi R24,32766
ldi R25,127
std y+1,R25
std y+0,R24
L199:
; {
; if((ReadFromCC1020Register(CC1020_STATUS)&0x10)==0x10) break;
ldi R16,64
rcall _ReadFromCC1020Register
mov R24,R16
andi R24,16
cpi R24,16
brne L203
rjmp L201
L203:
L200:
ldd R24,y+0
ldd R25,y+1
sbiw R24,1
std y+1,R25
std y+0,R24
clr R2
clr R3
cp R2,R24
cpc R3,R25
brlt L199
L201:
; }
;
; if(TimeOutCounter>0) break;
clr R2
clr R3
ldd R4,y+0
ldd R5,y+1
cp R2,R4
cpc R3,R5
brge L205
rjmp L185
L205:
L184:
ldd R24,y+2
ldd R25,y+3
sbiw R24,1
std y+3,R25
std y+2,R24
clr R2
clr R3
cp R2,R24
cpc R3,R25
brge X3
rjmp L183
X3:
L185:
; // Abort further recalibration attempts if successful LOCK
; // if((ReadFromCC1020Register(CC1020_STATUS)&0x10) == 0x10) {
; // break;
; // }
; }
;
; // Restore PA setting
; WriteToCC1020Register(CC1020_PA_POWER, PA_POWER);
mov R18,R20
ldi R16,28
rcall _WriteToCC1020Register
; // if((ReadFromCC1020Register(CC1020_STATUS)&0x10)!=0x10) SMG=dpybuffer[3];
; // Return state of LOCK_CONTINUOUS bit
; return ((ReadFromCC1020Register(CC1020_STATUS)&0x10)==0x10);
ldi R16,64
rcall _ReadFromCC1020Register
mov R24,R16
andi R24,16
cpi R24,16
brne L207
ldi R20,1
ldi R21,0
rjmp L208
L207:
clr R20
clr R21
L208:
mov R16,R20
L182:
adiw R28,4
rcall pop_gset1
.dbline 0 ; func end
ret
; lock_status -> R20
; TimeOutCounter -> y+0
; PA_POWER -> R22
; RXANALOG -> R20
.even
_SetupCC1020RX::
rcall push_gset2
mov R22,R18
mov R20,R16
sbiw R28,2
; }
;
; /****************************************************************************/
; /* This routine puts the CC1020 into RX mode (from TX). When switching to */
; /* RX from PD, use WakeupC1020ToRX first */
; /****************************************************************************/
;
; char SetupCC1020RX(char RXANALOG, char PA_POWER)
; {
; volatile int TimeOutCounter;
; char lock_status;
;
; // Switch into RX, switch to freq. reg A
; WriteToCC1020Register(CC1020_MAIN,0x11);
ldi R18,17
clr R16
rcall _WriteToCC1020Register
;
; // Setup bias current adjustment
; WriteToCC1020Register(CC1020_ANALOG,RXANALOG);
mov R18,R20
ldi R16,23
rcall _WriteToCC1020Register
ldi R24,32766
ldi R25,127
std y+1,R25
std y+0,R24
rjmp L213
L210:
L211:
ldd R24,y+0
ldd R25,y+1
sbiw R24,1
std y+1,R25
std y+0,R24
L213:
;
; // Monitor LOCK
; for(TimeOutCounter=LOCK_TIMEOUT; ((ReadFromCC1020Register(CC1020_STATUS)&0x10)==0)&&(TimeOutCounter>0); TimeOutCounter--);
ldi R16,64
rcall _ReadFromCC1020Register
sbrc R16,4
rjmp L214
clr R2
clr R3
ldd R4,y+0
ldd R5,y+1
cp R2,R4
cpc R3,R5
brlt L210
L214:
;
; // If PLL in lock
; if((ReadFromCC1020Register(CC1020_STATUS)&0x10)==0x10){
ldi R16,64
rcall _ReadFromCC1020Register
mov R24,R16
andi R24,16
cpi R24,16
brne L215
; // Indicate PLL in LOCK
; lock_status = LOCK_OK;
ldi R20,1
rjmp L216
L215:
; // Else (PLL out of LOCK)
; }else{
; // If recalibration ok
; if(CalibrateCC1020(PA_POWER)){
mov R16,R22
rcall _CalibrateCC1020
tst R16
breq L217
; // Indicate PLL in LOCK
; lock_status = LOCK_RECAL_OK;
ldi R20,2
rjmp L218
L217:
; // Else (recalibration failed)
; }else{
; // Indicate PLL out of LOCK
; lock_status = LOCK_NOK;
clr R20
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -