📄 main.lss
字号:
DQ_TO_1(); // 设置1-wire总线为高电平(释放总线)
130: 8b 98 cbi 0x11, 3 ; 17
milliseconds can be achieved.
*/
static __inline__ void
_delay_loop_2(uint16_t __count)
{
132: 83 e1 ldi r24, 0x13 ; 19
134: 90 e0 ldi r25, 0x00 ; 0
__asm__ volatile (
136: 01 97 sbiw r24, 0x01 ; 1
138: f1 f7 brne .-4 ; 0x136
DQ_TO_0(); // 设置1-wire总线为低电平(拉低总线以同步)
wait_us(4); // 2us
DQ_TO_1(); // 设置1-wire总线为高电平(释放总线)
wait_us(7); // 4us
dat >>= 1;
13a: 26 95 lsr r18
if(DQ_status()) dat|=0x80; // 读取总线电平，先收低位再收高位
13c: 83 99 sbic 0x10, 3 ; 16
13e: 20 68 ori r18, 0x80 ; 128
sei(); // 恢复系统中断
140: 78 94 sei
milliseconds can be achieved.
*/
static __inline__ void
_delay_loop_2(uint16_t __count)
{
142: 82 ee ldi r24, 0xE2 ; 226
144: 90 e0 ldi r25, 0x00 ; 0
__asm__ volatile (
146: 01 97 sbiw r24, 0x01 ; 1
148: f1 f7 brne .-4 ; 0x146
dat = 0x00; // 数据接收准备
// 每个字节共8位，一次收一位
for(count=0; count<8; count++) {
14a: 31 50 subi r19, 0x01 ; 1
14c: 37 ff sbrs r19, 7
14e: ea cf rjmp .-44 ; 0x124
cli(); // 保证绝对不会发生中断!
// 从总线拉低到读总线状态，不能大于15us!
DQ_TO_0(); // 设置1-wire总线为低电平(拉低总线以同步)
wait_us(4); // 2us
DQ_TO_1(); // 设置1-wire总线为高电平(释放总线)
wait_us(7); // 4us
dat >>= 1;
if(DQ_status()) dat|=0x80; // 读取总线电平，先收低位再收高位
sei(); // 恢复系统中断
wait_us(82); // 必须大于60us
}
return(dat);
}
150: 82 2f mov r24, r18
152: 99 27 eor r25, r25
154: 08 95 ret
00000156 <convert_T>:
/*-------------------------------------------------------
* 我的电路中只有一个器件DS18B20，所以不需要多个器件的ID
* 识别，跳过之后，启动温度转换，但在启动后，用户应等待几百个
* 毫秒，才能读到这次的转换值，这是DS18B20的数据手册规定的。
* 因为温度转换是需要时间的嘛!(^_^)
*/
void convert_T(void)
{
if(ds18b20_reset()==SUCC) { // 如果复位成功
156: 0e 94 5c 00 call 0xb8
15a: 81 30 cpi r24, 0x01 ; 1
15c: 31 f4 brne .+12 ; 0x16a
ds18b20_write(0xcc); // 跳过多器件识别
15e: 8c ec ldi r24, 0xCC ; 204
160: 0e 94 74 00 call 0xe8
ds18b20_write(0x44); // 启动温度转换
164: 84 e4 ldi r24, 0x44 ; 68
166: 0e 94 74 00 call 0xe8
16a: 08 95 ret
16c: 08 95 ret
0000016e <read_T>:
}
}
/*-------------------------------------------------------
* 读取转换后的温度值
* 我假定DS18B20一定是正确的，所以没有返回有关状态。当你故意
* 把DS18B20从电路中拔下而能让程序告诉你出错时，你可以自己修
* 改这段代码!
*/
unsigned int read_T(void)
{
16e: cf 93 push r28
170: df 93 push r29
unsigned int value=0;
172: c0 e0 ldi r28, 0x00 ; 0
174: d0 e0 ldi r29, 0x00 ; 0
if(ds18b20_reset()==SUCC) { // 如果复位成功
176: 0e 94 5c 00 call 0xb8
17a: 81 30 cpi r24, 0x01 ; 1
17c: 89 f4 brne .+34 ; 0x1a0
ds18b20_write(0xcc); // 跳过多器件识别
17e: 8c ec ldi r24, 0xCC ; 204
180: 0e 94 74 00 call 0xe8
ds18b20_write(0xbe); // 读暂存器
184: 8e eb ldi r24, 0xBE ; 190
186: 0e 94 74 00 call 0xe8
value = (unsigned int)ds18b20_read(); // 低字节
18a: 0e 94 90 00 call 0x120
18e: c8 2f mov r28, r24
190: dd 27 eor r29, r29
value += (unsigned int)(ds18b20_read())<<8; // 高字节
192: 0e 94 90 00 call 0x120
196: 99 27 eor r25, r25
198: 98 2f mov r25, r24
19a: 88 27 eor r24, r24
19c: c8 0f add r28, r24
19e: d9 1f adc r29, r25
}
return(value);
}
1a0: ce 01 movw r24, r28
1a2: df 91 pop r29
1a4: cf 91 pop r28
1a6: 08 95 ret
000001a8 <DS18B20_HEX_to_LCD>:
void DS18B20_HEX_to_LCD(unsigned int x,char *p)
{
1a8: fb 01 movw r30, r22
char temp;
char symbol='+';
1aa: 2b e2 ldi r18, 0x2B ; 43
temp=(unsigned char)((x&0x07ff)>>4);
1ac: ac 01 movw r20, r24
1ae: 57 70 andi r21, 0x07 ; 7
1b0: 64 e0 ldi r22, 0x04 ; 4
1b2: 56 95 lsr r21
1b4: 47 95 ror r20
1b6: 6a 95 dec r22
1b8: e1 f7 brne .-8 ; 0x1b2
if (x&0x800) symbol='-';
1ba: 89 2f mov r24, r25
1bc: 99 27 eor r25, r25
1be: 86 95 lsr r24
1c0: 86 95 lsr r24
1c2: 86 95 lsr r24
1c4: 80 fd sbrc r24, 0
1c6: 2d e2 ldi r18, 0x2D ; 45
p[0]=symbol;
1c8: 20 83 st Z, r18
p[1]=temp/100+'0';
1ca: 84 2f mov r24, r20
1cc: 64 e6 ldi r22, 0x64 ; 100
1ce: 0e 94 ee 01 call 0x3dc
1d2: 38 2f mov r19, r24
1d4: 30 5d subi r19, 0xD0 ; 208
1d6: 31 83 std Z+1, r19 ; 0x01
p[2]=temp%100/10+'0';
1d8: 84 2f mov r24, r20
1da: 0e 94 ee 01 call 0x3dc
1de: 29 2f mov r18, r25
1e0: 89 2f mov r24, r25
1e2: 6a e0 ldi r22, 0x0A ; 10
1e4: 0e 94 ee 01 call 0x3dc
1e8: 48 2f mov r20, r24
1ea: 40 5d subi r20, 0xD0 ; 208
1ec: 42 83 std Z+2, r20 ; 0x02
p[3]=temp%100%10+'0';
1ee: 82 2f mov r24, r18
1f0: 0e 94 ee 01 call 0x3dc
1f4: 89 2f mov r24, r25
1f6: 80 5d subi r24, 0xD0 ; 208
1f8: 83 83 std Z+3, r24 ; 0x03
if (p[1]=='0') {
1fa: 30 33 cpi r19, 0x30 ; 48
1fc: 31 f4 brne .+12 ; 0x20a
if (p[2]=='0') {p[2]=' ';}
1fe: 40 33 cpi r20, 0x30 ; 48
200: 11 f4 brne .+4 ; 0x206
202: 80 e2 ldi r24, 0x20 ; 32
204: 82 83 std Z+2, r24 ; 0x02
p[1]=' ';
206: 80 e2 ldi r24, 0x20 ; 32
208: 81 83 std Z+1, r24 ; 0x01
20a: 08 95 ret
20c: 08 95 ret
0000020e <USART_init>:
// UBRRL= 0x0C 19200;
// UBRRL= 0x19 9600;
// UBRRL= 0x33 4800;
// UBRRL= 0x67 2400
UCSRB |= (1<<RXEN)|(1<<TXEN); //允许发送和接收,|(1<<RXCIE)
20e: 8a b1 in r24, 0x0a ; 10
210: 88 61 ori r24, 0x18 ; 24
212: 8a b9 out 0x0a, r24 ; 10
UCSRC |= (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); //8位数据位+1位停止位
214: 80 b5 in r24, 0x20 ; 32
216: 86 68 ori r24, 0x86 ; 134
218: 80 bd out 0x20, r24 ; 32
UBRRH = 0x00;
21a: 10 bc out 0x20, r1 ; 32
UBRRL = 71;//9600 baud 6MHz:38 4MHz:25:71:11.0592
21c: 87 e4 ldi r24, 0x47 ; 71
21e: 89 b9 out 0x09, r24 ; 9
220: 08 95 ret
00000222 <put_char>:
//sei();
}
//标准I/O输出函数
int put_char(char c)
{
222: cf 93 push r28
224: c8 2f mov r28, r24
if(c == '\n')
226: 8a 30 cpi r24, 0x0A ; 10
228: 19 f4 brne .+6 ; 0x230
{
put_char('\r');
22a: 8d e0 ldi r24, 0x0D ; 13
22c: 0e 94 11 01 call 0x222
}
UDR = c;
230: cc b9 out 0x0c, r28 ; 12
while(!(UCSRA &(1<<UDRE)));
232: 5d 9b sbis 0x0b, 5 ; 11
234: fe cf rjmp .-4 ; 0x232
UCSRA |= (1<<UDRE);
236: 5d 9a sbi 0x0b, 5 ; 11
return 0;
}
238: 80 e0 ldi r24, 0x00 ; 0
23a: 90 e0 ldi r25, 0x00 ; 0
23c: cf 91 pop r28
23e: 08 95 ret
00000240 <get_char>:
//标准I/O输入函数
int get_char(void)
{
while(!(UCSRA &(1<<RXC)));
240: 5f 9b sbis 0x0b, 7 ; 11
242: fe cf rjmp .-4 ; 0x240
return UDR;
244: 8c b1 in r24, 0x0c ; 12
}
246: 99 27 eor r25, r25
248: 08 95 ret
0000024a <send_nbyte>:
//发送指定长度的字符串
void send_nbyte(unsigned char *p,unsigned char L)
{
24a: 0f 93 push r16
24c: 1f 93 push r17
24e: cf 93 push r28
unsigned char w;
for(w=0;w<L;w++)
250: 66 23 and r22, r22
252: 49 f0 breq .+18 ; 0x266
254: 8c 01 movw r16, r24
256: c6 2f mov r28, r22
{
// UDR = *(p+w);
// while(!(UCSRA &(1<<UDRE)));
//UCSRA |= (1<<UDRE);
put_char(*(p+w));
258: f8 01 movw r30, r16
25a: 81 91 ld r24, Z+
25c: 8f 01 movw r16, r30
25e: 0e 94 11 01 call 0x222
262: c1 50 subi r28, 0x01 ; 1
264: c9 f7 brne .-14 ; 0x258
266: cf 91 pop r28
268: 1f 91 pop r17
26a: 0f 91 pop r16
26c: 08 95 ret
0000026e <put_str>:
}
}
//发送字符串
void put_str(unsigned char *Str)
{
26e: cf 93 push r28
270: df 93 push r29
272: ec 01 movw r28, r24
while(*Str != '\0')
{
put_char(*Str);
Str++;
274: 88 81 ld r24, Y
276: 88 23 and r24, r24
278: 31 f0 breq .+12 ; 0x286
27a: 89 91 ld r24, Y+
27c: 0e 94 11 01 call 0x222
280: 88 81 ld r24, Y
282: 88 23 and r24, r24
284: d1 f7 brne .-12 ; 0x27a
286: df 91 pop r29
288: cf 91 pop r28
28a: 08 95 ret
0000028c <LCD_Write_half_char>:
}
/*---------写高4bit到LCD,4到7位连接----*/
void LCD_Write_half_char(unsigned data_in)
{
LCD_DATA_PORT &= 0X0f; //portd4~7=0
28c: 98 b3 in r25, 0x18 ; 24
28e: 9f 70 andi r25, 0x0F ; 15
290: 98 bb out 0x18, r25 ; 24
LCD_DATA_PORT |= data_in&0xf0; //send high 4bit
292: 98 2f mov r25, r24
294: 90 7f andi r25, 0xF0 ; 240
296: 88 b3 in r24, 0x18 ; 24
298: 89 2b or r24, r25
29a: 88 bb out 0x18, r24 ; 24
LCD_EN_PORT |= LCD_EN; //EN端产生一个由低电平变高电平，写LCD
29c: dd 9a sbi 0x1b, 5 ; 27
milliseconds can be achieved.
*/
static __inline__ void
_delay_loop_2(uint16_t __count)
{
29e: 89 e2 ldi r24, 0x29 ; 41
2a0: 90 e0 ldi r25, 0x00 ; 0
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -