📄 hello.lst
字号:
(0228) {
(0229) short val;
(0230)
(0231) val=(addr&0x7F)<<9 | (data&0xFF);
00D5 E029 LDI R18,0x9
00D6 E030 LDI R19,0
00D7 2F06 MOV R16,R22
00D8 2711 CLR R17
00D9 770F ANDI R16,0x7F
00DA 7010 ANDI R17,0
00DB 940E03B6 CALL lsl16
00DD 0118 MOVW R2,R16
00DE 2F84 MOV R24,R20
00DF 2799 CLR R25
00E0 7090 ANDI R25,0
00E1 2A28 OR R2,R24
00E2 2A39 OR R3,R25
00E3 8239 STD Y+1,R3
00E4 8228 STD Y+0,R2
(0232) ConfigureCC1000(1,&val);
00E5 019E MOVW R18,R28
00E6 E001 LDI R16,1
00E7 DFAF RCALL _ConfigureCC1000
00E8 9622 ADIW R28,2
00E9 940E0391 CALL pop_gset2
00EB 9508 RET
_WriteToCC1000RegisterWord:
addranddata --> Y+0
00EC 931A ST R17,-Y
00ED 930A ST R16,-Y
(0233) }
(0234)
(0235) /****************************************************************************/
(0236) /* This routine writes to a single CC1000 register, with data and address */
(0237) /* given in the same variable */
(0238) /****************************************************************************/
(0239)
(0240) void WriteToCC1000RegisterWord(short addranddata)
(0241) {
(0242)
(0243) ConfigureCC1000(1,&addranddata);
00EE 019E MOVW R18,R28
00EF E001 LDI R16,1
00F0 DFA6 RCALL _ConfigureCC1000
00F1 9622 ADIW R28,2
00F2 9508 RET
_ReadFromCC1000Register:
Debug --> R20
BitCounter --> R22
Data --> R10
addr --> R16
00F3 940E039B CALL push_gset3
(0244) }
(0245)
(0246) /****************************************************************************/////////////////////////原始的READ
(0247) /* This routine reads from a single CC1000 register */
(0248) /****************************************************************************/
(0249)
(0250) char ReadFromCC1000Register(char addr)
(0251) {
(0252) char BitCounter;
(0253) char Data;
(0254) char Debug;
(0255)
(0256)
(0257) PORTD|=(1<<PALE); //PALE=1
00F5 9A95 SBI 0x12,5
(0258)
(0259) Data=addr<<1;
00F6 2EA0 MOV R10,R16
00F7 0CAA LSL R10
(0260) PORTD&=~(1<<PALE);
00F8 9895 CBI 0x12,5
(0261)
(0262) /*Send address bits */
(0263) for (BitCounter=0;BitCounter<7;BitCounter++)
00F9 2766 CLR R22
00FA C009 RJMP 0x0104
(0264) {
(0265) PORTD|=(1<<PCLK); // PCLK=1
00FB 9A94 SBI 0x12,4
(0266) if ((Data&0x80)==0) {
00FC FCA7 SBRC R10,7
00FD C002 RJMP 0x0100
(0267) PORTD&=~(1<<PDATA); // PDATA=0
00FE 9893 CBI 0x12,3
(0268) }
00FF C001 RJMP 0x0101
(0269) else {
(0270) PORTD|=(1<<PDATA); // PDATA=1
0100 9A93 SBI 0x12,3
(0271) }
(0272) Data=Data<<1;
0101 0CAA LSL R10
(0273) PORTD&=~(1<<PCLK); //PCLK=0;
0102 9894 CBI 0x12,4
0103 9563 INC R22
0104 3067 CPI R22,7
0105 F3A8 BCS 0x00FB
(0274) }
(0275)
(0276) /*Send read/write bit */
(0277) /* Ignore bit in data, always use 0 */
(0278)
(0279) PORTD|=(1<<PCLK); //PCLK=1
0106 9A94 SBI 0x12,4
(0280) PORTD&=~(1<<PDATA); //PDATA=0
0107 9893 CBI 0x12,3
(0281) PORTD&=~(1<<PCLK); //PCLK=0
0108 9894 CBI 0x12,4
(0282)
(0283)
(0284) PORTD|=(1<<PCLK); //PCLK=1
0109 9A94 SBI 0x12,4
(0285) PORTD|=(1<<PALE); //PALE=1
010A 9A95 SBI 0x12,5
(0286)
(0287) /* Receive data bits */
(0288)
(0289) PORTD|=(1<<PDATA); //PDATA=1
010B 9A93 SBI 0x12,3
(0290)
(0291) DDRD&=~(1<<PDATA); /* Set up PDATA as an input */
010C 988B CBI 0x11,3
(0292)
(0293) for (BitCounter=0;BitCounter<8;BitCounter++)
010D 2766 CLR R22
010E C00F RJMP 0x011E
(0294) {
(0295) PORTD&=~(1<<PCLK); //PCLK=0
010F 9894 CBI 0x12,4
(0296) Data=Data<<1;
0110 0CAA LSL R10
(0297) Debug=(1<<PDATA);
0111 E048 LDI R20,0x8
(0298) if ((PIND&Debug)==0) {
0112 B220 IN R2,0x10
0113 2224 AND R2,R20
0114 F421 BNE 0x0119
(0299) Data&=0xFE;
0115 2D8A MOV R24,R10
0116 7F8E ANDI R24,0xFE
0117 2EA8 MOV R10,R24
(0300) } else {
0118 C003 RJMP 0x011C
(0301) Data|=0x01;
0119 2D8A MOV R24,R10
011A 6081 ORI R24,1
011B 2EA8 MOV R10,R24
(0302) }
(0303) PORTD|=(1<<PCLK); //PCLK=1
011C 9A94 SBI 0x12,4
011D 9563 INC R22
011E 3068 CPI R22,0x8
011F F378 BCS 0x010F
(0304) }
(0305)
(0306)
(0307) DDRD|=(1<<PDATA); /* Set up PDATA as an output again */
0120 9A8B SBI 0x11,3
(0308)
(0309) return Data;
0121 2D0A MOV R16,R10
0122 940E0394 CALL pop_gset3
0124 9508 RET
_ResetCC1000:
MainValue --> R20
0125 940E039F CALL push_gset1
(0310) }
(0311) /****************************************************************************/////////////////////////新的READ
(0312) /* This routine reads from a single CC1000 register */
(0313) /****************************************************************************/
(0314) /*
(0315) char ReadFromCC1000Register(char addr)
(0316) {
(0317) char BitCounter;
(0318) char Data;
(0319) char Debug;
(0320)
(0321)
(0322) PORTA|=(1<<PALE); //PALE=1
(0323)
(0324) Data=addr<<1;
(0325) PORTA&=~(1<<PALE);
(0326)
(0327) /* Send address bits */
(0328) /* for (BitCounter=0;BitCounter<7;BitCounter++)
(0329) {
(0330) PORTB|=(1<<PCLK); // PCLK=1
(0331) if ((Data&0x80)==0) {
(0332) PORTB&=~(1<<PDATA); // PDATA=0
(0333) }
(0334) else {
(0335) PORTB|=(1<<PDATA); // PDATA=1
(0336) }
(0337) Data=Data<<1;
(0338) PORTB&=~(1<<PCLK); //PCLK=0;
(0339) }
(0340)
(0341) /* Send read/write bit */
(0342) /* Ignore bit in data, always use 0 */
(0343) /*
(0344) PORTB|=(1<<PCLK); //PCLK=1
(0345) PORTB&=~(1<<PDATA); //PDATA=0
(0346) PORTB&=~(1<<PCLK); //PCLK=0
(0347)
(0348)
(0349) PORTB|=(1<<PCLK); //PCLK=1
(0350) PORTA|=(1<<PALE); //PALE=1
(0351)
(0352) /* Receive data bits */
(0353) /*
(0354) PORTB|=(1<<PDATA); //PDATA=1
(0355)
(0356) DDRD&=~(1<<PDATA); /* Set up PDATA as an input */
(0357) /*
(0358) for (BitCounter=0;BitCounter<8;BitCounter++)
(0359) {
(0360) PORTB&=~(1<<PCLK); //PCLK=0
(0361) Data=Data<<1;
(0362) Debug=(1<<PDATA);
(0363) if ((PIND&Debug)==0) {
(0364) Data&=0xFE;
(0365) } else {
(0366) Data|=0x01;
(0367) }
(0368) PORTB|=(1<<PCLK); //PCLK=1
(0369) }
(0370)
(0371)
(0372) DDRD|=(1<<PDATA); /* Set up PDATA as an output again */
(0373)
(0374) /* return Data;
(0375) }
(0376) /****************************************************************************/
(0377) /* This routine resets the CC1000, clearing all registers. */
(0378) /****************************************************************************/
(0379)
(0380) void ResetCC1000(void)
(0381) {
(0382) char MainValue;
(0383)
(0384) MainValue=ReadFromCC1000Register(CC1000_MAIN);
0127 2700 CLR R16
0128 DFCA RCALL _ReadFromCC1000Register
0129 2F40 MOV R20,R16
(0385) WriteToCC1000Register(CC1000_MAIN,MainValue & 0xFE); // Reset CC1000
012A 2F24 MOV R18,R20
012B 7F2E ANDI R18,0xFE
012C 2700 CLR R16
012D DFA2 RCALL _WriteToCC1000Register
(0386) WriteToCC1000Register(CC1000_MAIN,MainValue | 0x01); // Bring CC1000 out of reset
012E 2F24 MOV R18,R20
012F 6021 ORI R18,1
0130 2700 CLR R16
0131 DF9E RCALL _WriteToCC1000Register
0132 940E03A2 CALL pop_gset1
0134 9508 RET
_CalibrateCC1000:
TimeOutCounter --> R20
0135 940E039F CALL push_gset1
(0387) }
(0388)
(0389)
(0390) /****************************************************************************/
(0391) /* This routine calibrates the CC1000 */
(0392) /* Returns 0 if calibration fails, non-zero otherwise. Checks the LOCK */
(0393) /* to check for success. */
(0394) /****************************************************************************/
(0395)
(0396) char CalibrateCC1000(void)
(0397) {
(0398) int TimeOutCounter;
(0399)
(0400) WriteToCC1000Register(CC1000_PA_POW,0x00); // Turn off PA to avoid spurs
0137 2722 CLR R18
0138 E00B LDI R16,0xB
0139 DF96 RCALL _WriteToCC1000Register
(0401) // during calibration in TX mode
(0402) WriteToCC1000Register(CC1000_CAL,0xA6); // Start calibration
013A EA26 LDI R18,0xA6
013B E00E LDI R16,0xE
013C DF93 RCALL _WriteToCC1000Register
(0403)
(0404) // Wait for calibration complete
(0405) for(TimeOutCounter=CAL_TIMEOUT; ((ReadFromCC1000Register(CC1000_CAL)&0x08)==0)&&(TimeOutCounter>0); TimeOutCounter--);
013D EF4E LDI R20,0xFE
013E E75F LDI R21,0x7F
013F C002 RJMP 0x0142
0140 5041 SUBI R20,1
0141 4050 SBCI R21,0
0142 E00E LDI R16,0xE
0143 DFAF RCALL _ReadFromCC1000Register
0144 FD03 SBRC R16,3
0145 C005 RJMP 0x014B
0146 2422 CLR R2
0147 2433 CLR R3
0148 1624 CP R2,R20
0149 0635 CPC R3,R21
014A F3AC BLT 0x0140
(0406)
(0407) WriteToCC1000Register(CC1000_CAL,0x26); /* End calibration */
014B E226 LDI R18,0x26
014C E00E LDI R16,0xE
014D DF82 RCALL _WriteToCC1000Register
(0408) WriteToCC1000Register(CC1000_PA_POW,PA_VALUE); /* Restore PA setting */
014E EF20 LDI R18,0xF0
014F E00B LDI R16,0xB
0150 DF7F RCALL _WriteToCC1000Register
(0409) // Wait for lock
(0410) for(TimeOutCounter=LOCK_TIMEOUT; ((ReadFromCC1000Register(CC1000_LOCK)&0x01)==0)&&(TimeOutCounter>0); TimeOutCounter--);
0151 EF4E LDI R20,0xFE
0152 E75F LDI R21,0x7F
0153 C002 RJMP 0x0156
0154 5041 SUBI R20,1
0155 4050 SBCI R21,0
0156 E00D LDI R16,0xD
0157 DF9B RCALL _ReadFromCC1000Register
0158 FD00 SBRC R16,0
0159 C005 RJMP 0x015F
015A 2422 CLR R2
015B 2433 CLR R3
015C 1624 CP R2,R20
015D 0635 CPC R3,R21
015E F3AC BLT 0x0154
(0411)
(0412)
(0413)
(0414) return ((ReadFromCC1000Register(CC1000_LOCK)&0x01)==1);
015F E00D LDI R16,0xD
0160 DF92 RCALL _ReadFromCC1000Register
0161 2F80 MOV R24,R16
0162 7081 ANDI R24,1
0163 3081 CPI R24,1
0164 F419 BNE 0x0168
0165 E041 LDI R20,1
0166 E050 LDI R21,0
0167 C002 RJMP 0x016A
0168 2744 CLR R20
0169 2755 CLR R21
016A 2F04 MOV R16,R20
016B 940E03A2 CALL pop_gset1
016D 9508 RET
_SetupCC1000RX:
lock_status --> R20
i --> R20
RXPLL --> R22
RXCurrent --> R20
016E 940E039D CALL push_gset2
0170 2F62 MOV R22,R18
0171 2F40 MOV R20,R16
(0415) //return (1);
(0416) }
(0417)
(0418) /****************************************************************************/
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -