main.elf: file format elf32-avr
Sections:
Idx Name Size VMA LMA File off Algn
0 .data 00000030 00800100 0000108e 00001122 2**0
CONTENTS, ALLOC, LOAD, DATA
1 .text 0000108e 00000000 00000000 00000094 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
2 .bss 000002ce 00800130 00800130 00001152 2**0
ALLOC
3 .debug_aranges 00000020 00000000 00000000 00001152 2**0
CONTENTS, READONLY, DEBUGGING
4 .debug_pubnames 000002cc 00000000 00000000 00001172 2**0
CONTENTS, READONLY, DEBUGGING
5 .debug_info 00001456 00000000 00000000 0000143e 2**0
CONTENTS, READONLY, DEBUGGING
6 .debug_abbrev 000002ce 00000000 00000000 00002894 2**0
CONTENTS, READONLY, DEBUGGING
7 .debug_line 0000102e 00000000 00000000 00002b62 2**0
CONTENTS, READONLY, DEBUGGING
8 .debug_frame 00000220 00000000 00000000 00003b90 2**2
CONTENTS, READONLY, DEBUGGING
9 .debug_str 00000400 00000000 00000000 00003db0 2**0
CONTENTS, READONLY, DEBUGGING
10 .debug_loc 00000f71 00000000 00000000 000041b0 2**0
CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:
00000000 <__vectors>:
0: 0c 94 64 01 jmp 0x2c8 ; 0x2c8 <__ctors_end>
4: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
8: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
c: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
10: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
14: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
18: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
1c: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
20: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
24: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
28: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
2c: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
30: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
34: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
38: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
3c: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
40: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
44: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
48: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
4c: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
50: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
54: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
58: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
5c: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
60: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
64: 0c 94 81 01 jmp 0x302 ; 0x302 <__bad_interrupt>
00000068 <__c.2282>:
68: 48 54 54 50 2f 31 2e 30 20 34 30 31 20 55 6e 61 HTTP/1.0 401 Una
78: 75 74 68 6f 72 69 7a 65 64 0d 0a 43 6f 6e 74 65 uthorized..Conte
88: 6e 74 2d 54 79 70 65 3a 20 74 65 78 74 2f 68 74 nt-Type: text/ht
98: 6d 6c 0d 0a 0d 0a 3c 68 31 3e 34 30 31 20 55 6e ml....401 Un
a8: 61 75 74 68 6f 72 69 7a 65 64 3c 2f 68 31 3e 00 authorized
.
000000b8 <__c.2280>:
b8: 70 61 73 73 77 6f 72 64 3c 2f 70 3e 00 password.
000000c5 <__c.2278>:
c5: 3c 70 3e 55 73 61 67 65 3a 20 00 Usage: .
000000d0 <__c.2276>:
d0: 48 54 54 50 2f 31 2e 30 20 32 30 30 20 4f 4b 0d HTTP/1.0 200 OK.
e0: 0a 43 6f 6e 74 65 6e 74 2d 54 79 70 65 3a 20 74 .Content-Type: t
f0: 65 78 74 2f 68 74 6d 6c 0d 0a 0d 0a 00 ext/html.....
000000fd <__c.2273>:
fd: 48 54 54 50 2f 31 2e 30 20 32 30 30 20 4f 4b 0d HTTP/1.0 200 OK.
10d: 0a 43 6f 6e 74 65 6e 74 2d 54 79 70 65 3a 20 74 .Content-Type: t
11d: 65 78 74 2f 68 74 6d 6c 0d 0a 0d 0a 3c 68 31 3e ext/html....
12d: 32 30 30 20 4f 4b 3c 2f 68 31 3e 00 200 OK
.
00000139 <__c.2247>:
139: 20 ca f3 e1 c3 d3 2e d4 d2 d4 2e 20 32 30 31 32 .......... 2012
149: 20 00 .
0000014b <__c.2245>:
14b: 20 ea e0 ea 20 57 65 62 2d f1 e5 f0 e2 e5 f0 e0 ... Web-.......
15b: 2e 20 00 . .
0000015e <__c.2243>:
15e: 3c 2f 63 65 6e 74 65 72 3e 3c 62 72 3e 3c 68 72
............ ..
17e: e1 ee f2 fb 20 ef eb e0 f2 fb 20 00 .... ..... .
0000018a <__c.2241>:
18a: 2f 31 22 3e c2 ea eb fe f7 e8 f2 fc 3c 2f 61 3e /1">........
19a: 3c 70 3e 00 .
0000019e <__c.2239>:
19e: 2f 30 22 3e c2 fb ea eb fe f7 e8 f2 fc 3c 2f 61 /0">.........
.
000001b3 <__c.2237>:
1b3: 22 3e 5b cf f0 ee e2 e5 f0 e8 f2 fc 20 f1 ee f1 ">[......... ...
1c3: f2 ee ff ed e8 e5 5d 3c 2f 61 3e 3c 2f 73 6d 61 ......]
.:
1fa: c2 fb ea eb fe f7 e5 ed 00 .........
00000203 <__c.2231>:
203: 3c 66 6f 6e 74 20 63 6f 6c 6f 72 3d 22 23 30 30 ........
00000229 <__c.2229>:
229: 3c 63 65 6e 74 65 72 3e 3c 70 3e 3c 66 6f 6e 74 ....: .
00000258 <__c.2227>:
258: 3c 63 65 6e 74 65 72 3e 3c 66 6f 6e 74 20 73 69
..........
278: 20 c8 20 cc ce cd c8 d2 ce d0 c8 cd c3 20 d1 ce . .......... ..
288: d1 d2 ce df cd c8 df 20 d1 c2 c5 d2 ce c4 c8 ce ....... ........
298: c4 c0 00 ...
0000029b <__c.2225>:
29b: 48 54 54 50 2f 31 2e 30 20 32 30 30 20 4f 4b 0d HTTP/1.0 200 OK.
2ab: 0a 43 6f 6e 74 65 6e 74 2d 54 79 70 65 3a 20 74 .Content-Type: t
2bb: 65 78 74 2f 68 74 6d 6c 0d 0a 0d 0a 00 ext/html.....
000002c8 <__ctors_end>:
2c8: 11 24 eor r1, r1
2ca: 1f be out 0x3f, r1 ; 63
2cc: cf ef ldi r28, 0xFF ; 255
2ce: d4 e0 ldi r29, 0x04 ; 4
2d0: de bf out 0x3e, r29 ; 62
2d2: cd bf out 0x3d, r28 ; 61
000002d4 <__do_copy_data>:
2d4: 11 e0 ldi r17, 0x01 ; 1
2d6: a0 e0 ldi r26, 0x00 ; 0
2d8: b1 e0 ldi r27, 0x01 ; 1
2da: ee e8 ldi r30, 0x8E ; 142
2dc: f0 e1 ldi r31, 0x10 ; 16
2de: 02 c0 rjmp .+4 ; 0x2e4 <.do_copy_data_start>
000002e0 <.do_copy_data_loop>:
2e0: 05 90 lpm r0, Z+
2e2: 0d 92 st X+, r0
000002e4 <.do_copy_data_start>:
2e4: a0 33 cpi r26, 0x30 ; 48
2e6: b1 07 cpc r27, r17
2e8: d9 f7 brne .-10 ; 0x2e0 <.do_copy_data_loop>
000002ea <__do_clear_bss>:
2ea: 13 e0 ldi r17, 0x03 ; 3
2ec: a0 e3 ldi r26, 0x30 ; 48
2ee: b1 e0 ldi r27, 0x01 ; 1
2f0: 01 c0 rjmp .+2 ; 0x2f4 <.do_clear_bss_start>
000002f2 <.do_clear_bss_loop>:
2f2: 1d 92 st X+, r1
000002f4 <.do_clear_bss_start>:
2f4: ae 3f cpi r26, 0xFE ; 254
2f6: b1 07 cpc r27, r17
2f8: e1 f7 brne .-8 ; 0x2f2 <.do_clear_bss_loop>
2fa: 0e 94 2f 07 call 0xe5e ; 0xe5e
2fe: 0c 94 45 08 jmp 0x108a ; 0x108a <_exit>
00000302 <__bad_interrupt>:
302: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>
00000306 :
extern void make_tcp_ack_from_any(uint8_t *buf);
extern void make_tcp_ack_with_data(uint8_t *buf,uint16_t dlen);
uint16_t checksum(uint8_t *buf, uint16_t len, uint8_t type) // вычисляем контрольную сумму для ip заголовка
{
306: ef 92 push r14
308: ff 92 push r15
30a: 0f 93 push r16
30c: 1f 93 push r17
30e: cf 93 push r28
310: df 93 push r29
312: 7c 01 movw r14, r24
uint32_t sum = 0;
if(type==1)
314: 41 30 cpi r20, 0x01 ; 1
316: 61 f4 brne .+24 ; 0x330
{
sum+=IP_PROTO_UDP_V;
sum+=len-8;
318: 68 50 subi r22, 0x08 ; 8
31a: 70 40 sbci r23, 0x00 ; 0
31c: 9b 01 movw r18, r22
31e: 40 e0 ldi r20, 0x00 ; 0
320: 50 e0 ldi r21, 0x00 ; 0
322: 68 5f subi r22, 0xF8 ; 248
324: 7f 4f sbci r23, 0xFF ; 255
326: 2f 5e subi r18, 0xEF ; 239
328: 3f 4f sbci r19, 0xFF ; 255
32a: 4f 4f sbci r20, 0xFF ; 255
32c: 5f 4f sbci r21, 0xFF ; 255
32e: 12 c0 rjmp .+36 ; 0x354
}
if(type==2)
330: 42 30 cpi r20, 0x02 ; 2
332: 29 f0 breq .+10 ; 0x33e
334: 20 e0 ldi r18, 0x00 ; 0
336: 30 e0 ldi r19, 0x00 ; 0
338: 40 e0 ldi r20, 0x00 ; 0
33a: 50 e0 ldi r21, 0x00 ; 0
33c: 0b c0 rjmp .+22 ; 0x354
{
sum+=IP_PROTO_TCP_V;
sum+=len-8;
33e: 68 50 subi r22, 0x08 ; 8
340: 70 40 sbci r23, 0x00 ; 0
342: 9b 01 movw r18, r22
344: 40 e0 ldi r20, 0x00 ; 0
346: 50 e0 ldi r21, 0x00 ; 0
348: 68 5f subi r22, 0xF8 ; 248
34a: 7f 4f sbci r23, 0xFF ; 255
34c: 2a 5f subi r18, 0xFA ; 250
34e: 3f 4f sbci r19, 0xFF ; 255
350: 4f 4f sbci r20, 0xFF ; 255
352: 5f 4f sbci r21, 0xFF ; 255
354: e7 01 movw r28, r14
356: 8b 01 movw r16, r22
358: 0f c0 rjmp .+30 ; 0x378
}
while(len >1)
{
sum += 0xFFFF & (*buf<<8|*(buf+1));
35a: f8 81 ld r31, Y
35c: e0 e0 ldi r30, 0x00 ; 0
35e: 89 81 ldd r24, Y+1 ; 0x01
360: 90 e0 ldi r25, 0x00 ; 0
362: 8e 2b or r24, r30
364: 9f 2b or r25, r31
366: a0 e0 ldi r26, 0x00 ; 0
368: b0 e0 ldi r27, 0x00 ; 0
36a: 28 0f add r18, r24
36c: 39 1f adc r19, r25
36e: 4a 1f adc r20, r26
370: 5b 1f adc r21, r27
buf+=2;
372: 22 96 adiw r28, 0x02 ; 2
len-=2;
374: 02 50 subi r16, 0x02 ; 2
376: 10 40 sbci r17, 0x00 ; 0
if(type==2)
{
sum+=IP_PROTO_TCP_V;
sum+=len-8;
}
while(len >1)
378: 02 30 cpi r16, 0x02 ; 2
37a: 11 05 cpc r17, r1
37c: 70 f7 brcc .-36 ; 0x35a
37e: fb 01 movw r30, r22
380: ee 7f andi r30, 0xFE ; 254
382: ee 0d add r30, r14
384: ff 1d adc r31, r15
sum += 0xFFFF & (*buf<<8|*(buf+1));
buf+=2;
len-=2;
}
if (len)
386: 60 ff sbrs r22, 0
388: 0d c0 rjmp .+26 ; 0x3a4
{
sum += (0xFF & *buf)<<8;
38a: 90 81 ld r25, Z
38c: 80 e0 ldi r24, 0x00 ; 0
38e: aa 27 eor r26, r26
390: 97 fd sbrc r25, 7
392: a0 95 com r26
394: ba 2f mov r27, r26
396: 02 c0 rjmp .+4 ; 0x39c
}
while (sum>>16)
{
sum = (sum & 0xFFFF)+(sum >> 16);
398: 40 70 andi r20, 0x00 ; 0
39a: 50 70 andi r21, 0x00 ; 0
39c: 28 0f add r18, r24
39e: 39 1f adc r19, r25
3a0: 4a 1f adc r20, r26
3a2: 5b 1f adc r21, r27
if (len)
{
sum += (0xFF & *buf)<<8;
}
while (sum>>16)
3a4: ca 01 movw r24, r20
3a6: aa 27 eor r26, r26
3a8: bb 27 eor r27, r27
3aa: 00 97 sbiw r24, 0x00 ; 0
3ac: a1 05 cpc r26, r1
3ae: b1 05 cpc r27, r1
3b0: 99 f7 brne .-26 ; 0x398
3b2: 20 95 com r18
3b4: 30 95 com r19
{
sum = (sum & 0xFFFF)+(sum >> 16);
}
return( (uint16_t) sum ^ 0xFFFF);
}
3b6: c9 01 movw r24, r18
3b8: df 91 pop r29
3ba: cf 91 pop r28
3bc: 1f 91 pop r17
3be: 0f 91 pop r16
3c0: ff 90 pop r15
3c2: ef 90 pop r14
3c4: 08 95 ret
000003c6 :
void init_ip_arp(uint8_t *mymac,uint8_t *myip)// функция генерации ip- и MAC-адресов, которые будут переданы в пакет и фрейм соответственно
{
3c6: ac 01 movw r20, r24
3c8: 20 e0 ldi r18, 0x00 ; 0
3ca: 30 e0 ldi r19, 0x00 ; 0
uint8_t i=0;
while(i<4)
{
ipaddr[i]=myip[i];// присваиваем ip-адресу, который впоследствии будет отправлен в ip- пакете значение нашего ip
3cc: f9 01 movw r30, r18
3ce: e6 5c subi r30, 0xC6 ; 198
3d0: fe 4f sbci r31, 0xFE ; 254
3d2: db 01 movw r26, r22
3d4: a2 0f add r26, r18
3d6: b3 1f adc r27, r19
3d8: 8c 91 ld r24, X
3da: 80 83 st Z, r24
3dc: 2f 5f subi r18, 0xFF ; 255
3de: 3f 4f sbci r19, 0xFF ; 255
void init_ip_arp(uint8_t *mymac,uint8_t *myip)// функция генерации ip- и MAC-адресов, которые будут переданы в пакет и фрейм соответственно
{
uint8_t i=0;
while(i<4)
3e0: 24 30 cpi r18, 0x04 ; 4
3e2: 31 05 cpc r19, r1
3e4: 99 f7 brne .-26 ; 0x3cc
3e6: 20 e0 ldi r18, 0x00 ; 0
3e8: 30 e0 ldi r19, 0x00 ; 0
i++;
}
i=0;
while(i<6)
{
macaddr[i]=mymac[i];// присваиваем MAC-адресу, который впоследствии будет отправлен в Ethernet-фрейме значение нашего MAC
3ea: f9 01 movw r30, r18
3ec: ec 5c subi r30, 0xCC ; 204
3ee: fe 4f sbci r31, 0xFE ; 254
3f0: da 01 movw r26, r20
3f2: a2 0f add r26, r18
3f4: b3 1f adc r27, r19
3f6: 8c 91 ld r24, X
3f8: 80 83 st Z, r24
3fa: 2f 5f subi r18, 0xFF ; 255
3fc: 3f 4f sbci r19, 0xFF ; 255
{
ipaddr[i]=myip[i];// присваиваем ip-адресу, который впоследствии будет отправлен в ip- пакете значение нашего ip
i++;
}
i=0;
while(i<6)
3fe: 26 30 cpi r18, 0x06 ; 6
400: 31 05 cpc r19, r1
402: 99 f7 brne .-26 ; 0x3ea
{
macaddr[i]=mymac[i];// присваиваем MAC-адресу, который впоследствии будет отправлен в Ethernet-фрейме значение нашего MAC
i++;
}
}
404: 08 95 ret
00000406 :
uint8_t eth_type_is_arp_and_my_ip(uint8_t *buf,uint16_t len)// функция проверки, является ли полученный пакет ARP-запросом и предназначен ли нам?
{
406: fc 01 movw r30, r24
uint8_t i=0;
//
if (len<41)
408: 69 32 cpi r22, 0x29 ; 41
40a: 71 05 cpc r23, r1
40c: b0 f0 brcs .+44 ; 0x43a
{
return(0);
}
if(buf[ETH_TYPE_H_P] != ETHTYPE_ARP_H_V ||
40e: 84 85 ldd r24, Z+12 ; 0x0c
410: 88 30 cpi r24, 0x08 ; 8
412: 99 f4 brne .+38 ; 0x43a
414: 85 85 ldd r24, Z+13 ; 0x0d
416: 86 30 cpi r24, 0x06 ; 6
418: 81 f4 brne .+32 ; 0x43a
41a: df 01 movw r26, r30
41c: 96 96 adiw r26, 0x26 ; 38
41e: ea e3 ldi r30, 0x3A ; 58
420: f1 e0 ldi r31, 0x01 ; 1
{
return(0);
}
while(i<4)
{
if(buf[ETH_ARP_DST_IP_P+i] != ipaddr[i])
422: 9c 91 ld r25, X
424: 80 81 ld r24, Z
426: 98 17 cp r25, r24
428: 41 f4 brne .+16 ; 0x43a
42a: 11 96 adiw r26, 0x01 ; 1
42c: 31 96 adiw r30, 0x01 ; 1
if(buf[ETH_TYPE_H_P] != ETHTYPE_ARP_H_V ||
buf[ETH_TYPE_L_P] != ETHTYPE_ARP_L_V)
{
return(0);
}
while(i<4)
42e: 81 e0 ldi r24, 0x01 ; 1
430: ee 33 cpi r30, 0x3E ; 62
432: f8 07 cpc r31, r24
434: b1 f7 brne .-20 ; 0x422
436: 81 e0 ldi r24, 0x01 ; 1
438: 08 95 ret
43a: 80 e0 ldi r24, 0x00 ; 0
return(0);
}
i++;
}
return(1);//в случае успеха возвращает значение 1
}
43c: 08 95 ret
0000043e :
uint8_t eth_type_is_ip_and_my_ip(uint8_t *buf,uint16_t len)// функция проверки, адресован ли полученный IP пакет нам?
{uint8_t i=0;
43e: fc 01 movw r30, r24
if (len<42){
440: 6a 32 cpi r22, 0x2A ; 42
442: 71 05 cpc r23, r1
444: d0 f0 brcs .+52 ; 0x47a
return(0);
}
if(buf[ETH_TYPE_H_P]!=ETHTYPE_IP_H_V ||
446: 84 85 ldd r24, Z+12 ; 0x0c
448: 88 30 cpi r24, 0x08 ; 8
44a: b9 f4 brne .+46 ; 0x47a
44c: 85 85 ldd r24, Z+13 ; 0x0d
44e: 88 23 and r24, r24
450: a1 f4 brne .+40 ; 0x47a
buf[ETH_TYPE_L_P]!=ETHTYPE_IP_L_V){
return(0);
}
if (buf[IP_HEADER_LEN_VER_P]!=0x45){
452: 86 85 ldd r24, Z+14 ; 0x0e
454: 85 34 cpi r24, 0x45 ; 69
456: 89 f4 brne .+34 ; 0x47a
458: df 01 movw r26, r30
45a: ea e3 ldi r30, 0x3A ; 58
45c: f1 e0 ldi r31, 0x01 ; 1
return(0);
}
while(i<4){
if(buf[IP_DST_P+i]!=ipaddr[i]){
45e: 5e 96 adiw r26, 0x1e ; 30
460: 9c 91 ld r25, X
462: 5e 97 sbiw r26, 0x1e ; 30
464: 80 81 ld r24, Z
466: 98 17 cp r25, r24
468: 41 f4 brne .+16 ; 0x47a
46a: 11 96 adiw r26, 0x01 ; 1
46c: 31 96 adiw r30, 0x01 ; 1
}
if (buf[IP_HEADER_LEN_VER_P]!=0x45){
return(0);
}
while(i<4){
46e: 81 e0 ldi r24, 0x01 ; 1
470: ee 33 cpi r30, 0x3E ; 62
472: f8 07 cpc r31, r24
474: a1 f7 brne .-24 ; 0x45e
476: 81 e0 ldi r24, 0x01 ; 1
478: 08 95 ret
47a: 80 e0 ldi r24, 0x00 ; 0
return(0);
}
i++;
}
return(1);//если да, то возвращает 1
}
47c: 08 95 ret
0000047e :
void make_eth(uint8_t *buf)//функция замены MAC-адреса источника на МАС-адрес получателя
{
47e: fc 01 movw r30, r24
480: a4 e3 ldi r26, 0x34 ; 52
482: b1 e0 ldi r27, 0x01 ; 1
uint8_t i=0;
while(i<6){
buf[ETH_DST_MAC +i]=buf[ETH_SRC_MAC +i];
484: 86 81 ldd r24, Z+6 ; 0x06
486: 80 83 st Z, r24
buf[ETH_SRC_MAC +i]=macaddr[i];
488: 8d 91 ld r24, X+
48a: 86 83 std Z+6, r24 ; 0x06
48c: 31 96 adiw r30, 0x01 ; 1
void make_eth(uint8_t *buf)//функция замены MAC-адреса источника на МАС-адрес получателя
{
uint8_t i=0;
while(i<6){
48e: 81 e0 ldi r24, 0x01 ; 1
490: aa 33 cpi r26, 0x3A ; 58
492: b8 07 cpc r27, r24
494: b9 f7 brne .-18 ; 0x484
buf[ETH_DST_MAC +i]=buf[ETH_SRC_MAC +i];
buf[ETH_SRC_MAC +i]=macaddr[i];
i++;
}
}
496: 08 95 ret
00000498 :
void fill_ip_hdr_checksum(uint8_t *buf)// функция генерации контрольной суммы, флагов, времени жизни для отправляемого IP пакета
{
498: 0f 93 push r16
49a: 1f 93 push r17
49c: 8c 01 movw r16, r24
uint16_t ck;
buf[IP_CHECKSUM_P]=0;
49e: fc 01 movw r30, r24
4a0: 10 8e std Z+24, r1 ; 0x18
buf[IP_CHECKSUM_P+1]=0;
4a2: 11 8e std Z+25, r1 ; 0x19
buf[IP_FLAGS_P]=0x40;
4a4: 80 e4 ldi r24, 0x40 ; 64
4a6: 84 8b std Z+20, r24 ; 0x14
buf[IP_FLAGS_P+1]=0;
4a8: 15 8a std Z+21, r1 ; 0x15
buf[IP_TTL_P]=64;
4aa: 86 8b std Z+22, r24 ; 0x16
ck=checksum(&buf[IP_P], IP_HEADER_LEN,0);
4ac: c8 01 movw r24, r16
4ae: 0e 96 adiw r24, 0x0e ; 14
4b0: 64 e1 ldi r22, 0x14 ; 20
4b2: 70 e0 ldi r23, 0x00 ; 0
4b4: 40 e0 ldi r20, 0x00 ; 0
4b6: 0e 94 83 01 call 0x306 ; 0x306
buf[IP_CHECKSUM_P]=ck>>8;
4ba: f8 01 movw r30, r16
4bc: 90 8f std Z+24, r25 ; 0x18
buf[IP_CHECKSUM_P+1]=ck& 0xff;
4be: 81 8f std Z+25, r24 ; 0x19
}
4c0: 1f 91 pop r17
4c2: 0f 91 pop r16
4c4: 08 95 ret
000004c6 :
void make_ip(uint8_t *buf)//функция генерации ip пакета для отправления
{
4c6: ac 01 movw r20, r24
4c8: fc 01 movw r30, r24
4ca: aa e3 ldi r26, 0x3A ; 58
4cc: b1 e0 ldi r27, 0x01 ; 1
uint8_t i=0;
while(i<4)
{
buf[IP_DST_P+i]=buf[IP_SRC_P+i];
4ce: 82 8d ldd r24, Z+26 ; 0x1a
4d0: 86 8f std Z+30, r24 ; 0x1e
buf[IP_SRC_P+i]=ipaddr[i];
4d2: 8d 91 ld r24, X+
4d4: 82 8f std Z+26, r24 ; 0x1a
4d6: 31 96 adiw r30, 0x01 ; 1
void make_ip(uint8_t *buf)//функция генерации ip пакета для отправления
{
uint8_t i=0;
while(i<4)
4d8: 81 e0 ldi r24, 0x01 ; 1
4da: ae 33 cpi r26, 0x3E ; 62
4dc: b8 07 cpc r27, r24
4de: b9 f7 brne .-18 ; 0x4ce
{
buf[IP_DST_P+i]=buf[IP_SRC_P+i];
buf[IP_SRC_P+i]=ipaddr[i];
i++;
}
fill_ip_hdr_checksum(buf);
4e0: ca 01 movw r24, r20
4e2: 0e 94 4c 02 call 0x498 ; 0x498
}
4e6: 08 95 ret
000004e8 :
buf[ICMP_CHECKSUM_P]+=0x08;
//
enc28j60PacketSend(len,buf);
}
void make_tcphead(uint8_t *buf,uint16_t rel_ack_num,uint8_t mss,uint8_t cp_seq)//функция генерации заголовка TCP для последующей отправки
{
4e8: fc 01 movw r30, r24
uint8_t i=0;
uint8_t tseq;
while(i<2)
{
buf[TCP_DST_PORT_H_P+i]=buf[TCP_SRC_PORT_H_P+i];
4ea: 82 a1 ldd r24, Z+34 ; 0x22
4ec: 84 a3 std Z+36, r24 ; 0x24
buf[TCP_SRC_PORT_H_P+i]=0; // clear source port
4ee: 12 a2 std Z+34, r1 ; 0x22
{
uint8_t i=0;
uint8_t tseq;
while(i<2)
{
buf[TCP_DST_PORT_H_P+i]=buf[TCP_SRC_PORT_H_P+i];
4f0: 83 a1 ldd r24, Z+35 ; 0x23
4f2: 85 a3 std Z+37, r24 ; 0x25
buf[TCP_SRC_PORT_H_P+i]=0; // clear source port
i++;
}
buf[TCP_SRC_PORT_L_P]=80;
4f4: 80 e5 ldi r24, 0x50 ; 80
4f6: 83 a3 std Z+35, r24 ; 0x23
buf[ICMP_CHECKSUM_P]+=0x08;
//
enc28j60PacketSend(len,buf);
}
void make_tcphead(uint8_t *buf,uint16_t rel_ack_num,uint8_t mss,uint8_t cp_seq)//функция генерации заголовка TCP для последующей отправки
{
4f8: df 01 movw r26, r30
4fa: 99 96 adiw r26, 0x29 ; 41
4fc: 94 e0 ldi r25, 0x04 ; 4
buf[TCP_SRC_PORT_L_P]=80;
i=4;
while(i>0)
{
rel_ack_num=buf[TCP_SEQ_H_P+i-1]+rel_ack_num;
4fe: 8c 91 ld r24, X
500: 68 0f add r22, r24
502: 71 1d adc r23, r1
tseq=buf[TCP_SEQACK_H_P+i-1];
504: 14 96 adiw r26, 0x04 ; 4
506: 8c 91 ld r24, X
508: 14 97 sbiw r26, 0x04 ; 4
buf[TCP_SEQACK_H_P+i-1]=0xff&rel_ack_num;
50a: 14 96 adiw r26, 0x04 ; 4
50c: 6c 93 st X, r22
50e: 14 97 sbiw r26, 0x04 ; 4
if (cp_seq)
510: 22 23 and r18, r18
512: 11 f0 breq .+4 ; 0x518 <__stack+0x19>
{
buf[TCP_SEQ_H_P+i-1]=tseq;
514: 8c 93 st X, r24
516: 01 c0 rjmp .+2 ; 0x51a <__stack+0x1b>
}
else
{
buf[TCP_SEQ_H_P+i-1]= 0;
518: 1c 92 st X, r1
}
rel_ack_num=rel_ack_num>>8;
i--;
51a: 91 50 subi r25, 0x01 ; 1
51c: 11 97 sbiw r26, 0x01 ; 1
i++;
}
buf[TCP_SRC_PORT_L_P]=80;
i=4;
while(i>0)
51e: 99 23 and r25, r25
520: 19 f0 breq .+6 ; 0x528 <__stack+0x29>
}
else
{
buf[TCP_SEQ_H_P+i-1]= 0;
}
rel_ack_num=rel_ack_num>>8;
522: 67 2f mov r22, r23
524: 77 27 eor r23, r23
526: eb cf rjmp .-42 ; 0x4fe
i--;
}
if (cp_seq==0)
528: 22 23 and r18, r18
52a: 49 f4 brne .+18 ; 0x53e <__stack+0x3f>
{
buf[TCP_SEQ_H_P+0]= 0;
52c: 16 a2 std Z+38, r1 ; 0x26
buf[TCP_SEQ_H_P+1]= 0;
52e: 17 a2 std Z+39, r1 ; 0x27
buf[TCP_SEQ_H_P+2]= seqnum;
530: 80 91 2e 01 lds r24, 0x012E
534: 80 a7 std Z+40, r24 ; 0x28
buf[TCP_SEQ_H_P+3]= 0;
536: 11 a6 std Z+41, r1 ; 0x29
seqnum+=2;
538: 8e 5f subi r24, 0xFE ; 254
53a: 80 93 2e 01 sts 0x012E, r24
}
buf[TCP_CHECKSUM_H_P]=0;
53e: 12 aa std Z+50, r1 ; 0x32
buf[TCP_CHECKSUM_L_P]=0;
540: 13 aa std Z+51, r1 ; 0x33
if (mss)
542: 44 23 and r20, r20
544: 51 f0 breq .+20 ; 0x55a <__stack+0x5b>
{
buf[TCP_OPTIONS_P]=2;
546: 82 e0 ldi r24, 0x02 ; 2
548: 86 ab std Z+54, r24 ; 0x36
buf[TCP_OPTIONS_P+1]=4;
54a: 84 e0 ldi r24, 0x04 ; 4
54c: 87 ab std Z+55, r24 ; 0x37
buf[TCP_OPTIONS_P+2]=0x05;
54e: 85 e0 ldi r24, 0x05 ; 5
550: 80 af std Z+56, r24 ; 0x38
buf[TCP_OPTIONS_P+3]=0x80;
552: 80 e8 ldi r24, 0x80 ; 128
554: 81 af std Z+57, r24 ; 0x39
buf[TCP_HEADER_LEN_P]=0x60;
556: 80 e6 ldi r24, 0x60 ; 96
558: 01 c0 rjmp .+2 ; 0x55c <__stack+0x5d>
}
else
{
buf[TCP_HEADER_LEN_P]=0x50;
55a: 80 e5 ldi r24, 0x50 ; 80
55c: 86 a7 std Z+46, r24 ; 0x2e
55e: 08 95 ret
00000560 :
buf[TCP_CHECKSUM_L_P]=ck& 0xff;
enc28j60PacketSend(IP_HEADER_LEN+TCP_HEADER_LEN_PLAIN+4+ETH_HEADER_LEN,buf);
}
uint16_t get_tcp_data_pointer(void)//функция расчета положения первого октета данных в буфере
{
if (info_data_len)
560: 80 91 30 01 lds r24, 0x0130
564: 90 91 31 01 lds r25, 0x0131
568: 89 2b or r24, r25
56a: 19 f4 brne .+6 ; 0x572
56c: 20 e0 ldi r18, 0x00 ; 0
56e: 30 e0 ldi r19, 0x00 ; 0
570: 06 c0 rjmp .+12 ; 0x57e
{
return((uint16_t)TCP_SRC_PORT_H_P+info_hdr_len);
572: 20 91 32 01 lds r18, 0x0132
576: 30 91 33 01 lds r19, 0x0133
57a: 2e 5d subi r18, 0xDE ; 222
57c: 3f 4f sbci r19, 0xFF ; 255
}
else
{
return(0);
}
}
57e: c9 01 movw r24, r18
580: 08 95 ret
00000582 :
void init_len_info(uint8_t *buf)//функция определения размера TCP заголовка и принятых данных
{
582: fc 01 movw r30, r24
info_data_len=(buf[IP_TOTLEN_H_P]<<8)|(buf[IP_TOTLEN_L_P]&0xff);
584: 90 89 ldd r25, Z+16 ; 0x10
586: 80 e0 ldi r24, 0x00 ; 0
588: 21 89 ldd r18, Z+17 ; 0x11
58a: 30 e0 ldi r19, 0x00 ; 0
58c: 28 2b or r18, r24
58e: 39 2b or r19, r25
info_data_len-=IP_HEADER_LEN;
info_hdr_len=(buf[TCP_HEADER_LEN_P]>>4)*4;
590: 86 a5 ldd r24, Z+46 ; 0x2e
592: 82 95 swap r24
594: 8f 70 andi r24, 0x0F ; 15
596: 90 e0 ldi r25, 0x00 ; 0
598: 88 0f add r24, r24
59a: 99 1f adc r25, r25
59c: 88 0f add r24, r24
59e: 99 1f adc r25, r25
5a0: 90 93 33 01 sts 0x0133, r25
5a4: 80 93 32 01 sts 0x0132, r24
info_data_len-=info_hdr_len;
5a8: 24 51 subi r18, 0x14 ; 20
5aa: 30 40 sbci r19, 0x00 ; 0
5ac: 28 1b sub r18, r24
5ae: 39 0b sbc r19, r25
5b0: 30 93 31 01 sts 0x0131, r19
5b4: 20 93 30 01 sts 0x0130, r18
if (info_data_len<=0)
5b8: 12 16 cp r1, r18
5ba: 13 06 cpc r1, r19
5bc: 24 f0 brlt .+8 ; 0x5c6
{
info_data_len=0;
5be: 10 92 31 01 sts 0x0131, r1
5c2: 10 92 30 01 sts 0x0130, r1
5c6: 08 95 ret
000005c8 :
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
5c8: 6a 5c subi r22, 0xCA ; 202
5ca: 7f 4f sbci r23, 0xFF ; 255
5cc: dc 01 movw r26, r24
5ce: a6 0f add r26, r22
5d0: b7 1f adc r27, r23
5d2: 66 53 subi r22, 0x36 ; 54
5d4: 70 40 sbci r23, 0x00 ; 0
5d6: 03 c0 rjmp .+6 ; 0x5de
char c;
while ((c = pgm_read_byte(progmem_s++)))
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
5d8: 8d 93 st X+, r24
pos++;
5da: 6f 5f subi r22, 0xFF ; 255
5dc: 7f 4f sbci r23, 0xFF ; 255
5de: fa 01 movw r30, r20
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
5e0: 4f 5f subi r20, 0xFF ; 255
5e2: 5f 4f sbci r21, 0xFF ; 255
5e4: 84 91 lpm r24, Z+
5e6: 88 23 and r24, r24
5e8: b9 f7 brne .-18 ; 0x5d8
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
pos++;
}
return(pos);
}
5ea: cb 01 movw r24, r22
5ec: 08 95 ret
000005ee :
uint16_t fill_tcp_data(uint8_t *buf,uint16_t pos, const char *s)//функция записи строковых данных в буфер
{
5ee: fa 01 movw r30, r20
5f0: 6a 5c subi r22, 0xCA ; 202
5f2: 7f 4f sbci r23, 0xFF ; 255
5f4: dc 01 movw r26, r24
5f6: a6 0f add r26, r22
5f8: b7 1f adc r27, r23
5fa: 66 53 subi r22, 0x36 ; 54
5fc: 70 40 sbci r23, 0x00 ; 0
5fe: 04 c0 rjmp .+8 ; 0x608
while (*s)
{
buf[TCP_CHECKSUM_L_P+3+pos]=*s;
600: 8d 93 st X+, r24
pos++;
602: 6f 5f subi r22, 0xFF ; 255
604: 7f 4f sbci r23, 0xFF ; 255
s++;
606: 31 96 adiw r30, 0x01 ; 1
}
return(pos);
}
uint16_t fill_tcp_data(uint8_t *buf,uint16_t pos, const char *s)//функция записи строковых данных в буфер
{
while (*s)
608: 80 81 ld r24, Z
60a: 88 23 and r24, r24
60c: c9 f7 brne .-14 ; 0x600
buf[TCP_CHECKSUM_L_P+3+pos]=*s;
pos++;
s++;
}
return(pos);
}
60e: cb 01 movw r24, r22
610: 08 95 ret
00000612 :
#define waitspi() while(!(SPSR&(1<
// read data
SPDR = 0x00;
622: 1e bc out 0x2e, r1 ; 46
waitspi();
624: 0d b4 in r0, 0x2d ; 45
626: 07 fe sbrs r0, 7
628: fd cf rjmp .-6 ; 0x624
// do dummy read if needed (for mac and mii, see datasheet page 29)
if(address & 0x80)
62a: 67 ff sbrs r22, 7
62c: 04 c0 rjmp .+8 ; 0x636
{
SPDR = 0x00;
62e: 1e bc out 0x2e, r1 ; 46
waitspi();
630: 0d b4 in r0, 0x2d ; 45
632: 07 fe sbrs r0, 7
634: fd cf rjmp .-6 ; 0x630
}
// release CS
CSPASSIVE;
636: 2a 9a sbi 0x05, 2 ; 5
return(SPDR);
638: 8e b5 in r24, 0x2e ; 46
}
63a: 08 95 ret
0000063c :
void enc28j60WriteOp(uint8_t op, uint8_t address, uint8_t data)
{
CSACTIVE;
63c: 2a 98 cbi 0x05, 2 ; 5
// issue write command
SPDR = op | (address & ADDR_MASK);
63e: 6f 71 andi r22, 0x1F ; 31
640: 68 2b or r22, r24
642: 6e bd out 0x2e, r22 ; 46
waitspi();
644: 0d b4 in r0, 0x2d ; 45
646: 07 fe sbrs r0, 7
648: fd cf rjmp .-6 ; 0x644
// write data
SPDR = data;
64a: 4e bd out 0x2e, r20 ; 46
waitspi();
64c: 0d b4 in r0, 0x2d ; 45
64e: 07 fe sbrs r0, 7
650: fd cf rjmp .-6 ; 0x64c
CSPASSIVE;
652: 2a 9a sbi 0x05, 2 ; 5
}
654: 08 95 ret
00000656 :
void enc28j60ReadBuffer(uint16_t len, uint8_t* data)
{
656: ac 01 movw r20, r24
658: fb 01 movw r30, r22
CSACTIVE;
65a: 2a 98 cbi 0x05, 2 ; 5
// issue read command
SPDR = ENC28J60_READ_BUF_MEM;
65c: 8a e3 ldi r24, 0x3A ; 58
65e: 8e bd out 0x2e, r24 ; 46
waitspi();
660: 0d b4 in r0, 0x2d ; 45
662: 07 fe sbrs r0, 7
664: fd cf rjmp .-6 ; 0x660
666: 9a 01 movw r18, r20
668: df 01 movw r26, r30
66a: 08 c0 rjmp .+16 ; 0x67c
while(len)
{
len--;
// read data
SPDR = 0x00;
66c: 1e bc out 0x2e, r1 ; 46
waitspi();
66e: 0d b4 in r0, 0x2d ; 45
670: 07 fe sbrs r0, 7
672: fd cf rjmp .-6 ; 0x66e
// issue read command
SPDR = ENC28J60_READ_BUF_MEM;
waitspi();
while(len)
{
len--;
674: 21 50 subi r18, 0x01 ; 1
676: 30 40 sbci r19, 0x00 ; 0
// read data
SPDR = 0x00;
waitspi();
*data = SPDR;
678: 8e b5 in r24, 0x2e ; 46
67a: 8d 93 st X+, r24
{
CSACTIVE;
// issue read command
SPDR = ENC28J60_READ_BUF_MEM;
waitspi();
while(len)
67c: 21 15 cp r18, r1
67e: 31 05 cpc r19, r1
680: a9 f7 brne .-22 ; 0x66c
SPDR = 0x00;
waitspi();
*data = SPDR;
data++;
}
*data='\0';
682: e4 0f add r30, r20
684: f5 1f adc r31, r21
686: 10 82 st Z, r1
CSPASSIVE;
688: 2a 9a sbi 0x05, 2 ; 5
}
68a: 08 95 ret
0000068c :
void enc28j60WriteBuffer(uint16_t len, uint8_t* data)
{
68c: 9c 01 movw r18, r24
68e: fb 01 movw r30, r22
CSACTIVE;
690: 2a 98 cbi 0x05, 2 ; 5
// issue write command
SPDR = ENC28J60_WRITE_BUF_MEM;
692: 8a e7 ldi r24, 0x7A ; 122
694: 8e bd out 0x2e, r24 ; 46
waitspi();
696: 0d b4 in r0, 0x2d ; 45
698: 07 fe sbrs r0, 7
69a: fd cf rjmp .-6 ; 0x696
69c: 08 c0 rjmp .+16 ; 0x6ae
while(len)
{
len--;
// write data
SPDR = *data;
69e: 80 81 ld r24, Z
6a0: 8e bd out 0x2e, r24 ; 46
data++;
waitspi();
6a2: 0d b4 in r0, 0x2d ; 45
6a4: 07 fe sbrs r0, 7
6a6: fd cf rjmp .-6 ; 0x6a2
// issue write command
SPDR = ENC28J60_WRITE_BUF_MEM;
waitspi();
while(len)
{
len--;
6a8: 21 50 subi r18, 0x01 ; 1
6aa: 30 40 sbci r19, 0x00 ; 0
// write data
SPDR = *data;
data++;
6ac: 31 96 adiw r30, 0x01 ; 1
{
CSACTIVE;
// issue write command
SPDR = ENC28J60_WRITE_BUF_MEM;
waitspi();
while(len)
6ae: 21 15 cp r18, r1
6b0: 31 05 cpc r19, r1
6b2: a9 f7 brne .-22 ; 0x69e
// write data
SPDR = *data;
data++;
waitspi();
}
CSPASSIVE;
6b4: 2a 9a sbi 0x05, 2 ; 5
}
6b6: 08 95 ret
000006b8 :
void enc28j60SetBank(uint8_t address)
{
6b8: 1f 93 push r17
6ba: cf 93 push r28
6bc: df 93 push r29
6be: 18 2f mov r17, r24
// set the bank (if needed)
if((address & BANK_MASK) != Enc28j60Bank)
6c0: c8 2f mov r28, r24
6c2: d0 e0 ldi r29, 0x00 ; 0
6c4: c0 76 andi r28, 0x60 ; 96
6c6: d0 70 andi r29, 0x00 ; 0
6c8: 80 91 3e 01 lds r24, 0x013E
6cc: 90 e0 ldi r25, 0x00 ; 0
6ce: c8 17 cp r28, r24
6d0: d9 07 cpc r29, r25
6d2: 91 f0 breq .+36 ; 0x6f8
{
// set the bank
enc28j60WriteOp(ENC28J60_BIT_FIELD_CLR, ECON1, (ECON1_BSEL1|ECON1_BSEL0));
6d4: 80 ea ldi r24, 0xA0 ; 160
6d6: 6f e1 ldi r22, 0x1F ; 31
6d8: 43 e0 ldi r20, 0x03 ; 3
6da: 0e 94 1e 03 call 0x63c ; 0x63c
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, (address & BANK_MASK)>>5);
6de: 55 e0 ldi r21, 0x05 ; 5
6e0: d5 95 asr r29
6e2: c7 95 ror r28
6e4: 5a 95 dec r21
6e6: e1 f7 brne .-8 ; 0x6e0
6e8: 80 e8 ldi r24, 0x80 ; 128
6ea: 6f e1 ldi r22, 0x1F ; 31
6ec: 4c 2f mov r20, r28
6ee: 0e 94 1e 03 call 0x63c ; 0x63c
Enc28j60Bank = (address & BANK_MASK);
6f2: 10 76 andi r17, 0x60 ; 96
6f4: 10 93 3e 01 sts 0x013E, r17
}
}
6f8: df 91 pop r29
6fa: cf 91 pop r28
6fc: 1f 91 pop r17
6fe: 08 95 ret
00000700 :
uint8_t enc28j60Read(uint8_t address)
{
700: 1f 93 push r17
702: 18 2f mov r17, r24
// set the bank
enc28j60SetBank(address);
704: 0e 94 5c 03 call 0x6b8 ; 0x6b8
// do the read
return enc28j60ReadOp(ENC28J60_READ_CTRL_REG, address);
708: 80 e0 ldi r24, 0x00 ; 0
70a: 61 2f mov r22, r17
70c: 0e 94 09 03 call 0x612 ; 0x612
}
710: 1f 91 pop r17
712: 08 95 ret
00000714 :
void enc28j60Write(uint8_t address, uint8_t data)
{
714: 0f 93 push r16
716: 1f 93 push r17
718: 18 2f mov r17, r24
71a: 06 2f mov r16, r22
// set the bank
enc28j60SetBank(address);
71c: 0e 94 5c 03 call 0x6b8 ; 0x6b8
// do the write
enc28j60WriteOp(ENC28J60_WRITE_CTRL_REG, address, data);
720: 80 e4 ldi r24, 0x40 ; 64
722: 61 2f mov r22, r17
724: 40 2f mov r20, r16
726: 0e 94 1e 03 call 0x63c ; 0x63c
}
72a: 1f 91 pop r17
72c: 0f 91 pop r16
72e: 08 95 ret
00000730 :
void enc28j60PhyWrite(uint8_t address, uint16_t data)
{
730: 0f 93 push r16
732: 1f 93 push r17
734: 98 2f mov r25, r24
736: 16 2f mov r17, r22
738: 07 2f mov r16, r23
// set the PHY register address
enc28j60Write(MIREGADR, address);
73a: 84 ed ldi r24, 0xD4 ; 212
73c: 69 2f mov r22, r25
73e: 0e 94 8a 03 call 0x714 ; 0x714
// write the PHY data
enc28j60Write(MIWRL, data);
742: 86 ed ldi r24, 0xD6 ; 214
744: 61 2f mov r22, r17
746: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(MIWRH, data>>8);
74a: 87 ed ldi r24, 0xD7 ; 215
74c: 60 2f mov r22, r16
74e: 0e 94 8a 03 call 0x714 ; 0x714
can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
__asm__ volatile (
752: 18 e2 ldi r17, 0x28 ; 40
754: 03 c0 rjmp .+6 ; 0x75c
756: 81 2f mov r24, r17
758: 8a 95 dec r24
75a: f1 f7 brne .-4 ; 0x758
// wait until the PHY write completes
while(enc28j60Read(MISTAT) & MISTAT_BUSY){
75c: 8a ee ldi r24, 0xEA ; 234
75e: 0e 94 80 03 call 0x700 ; 0x700
762: 80 fd sbrc r24, 0
764: f8 cf rjmp .-16 ; 0x756
_delay_us(15);
}
}
766: 1f 91 pop r17
768: 0f 91 pop r16
76a: 08 95 ret
0000076c :
void enc28j60Init(uint8_t* macaddr)
{
76c: cf 93 push r28
76e: df 93 push r29
770: ec 01 movw r28, r24
// initialize I/O
ENC28J60_CONTROL_DDR |= 1<
798: 84 ef ldi r24, 0xF4 ; 244
79a: 91 e0 ldi r25, 0x01 ; 1
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
79c: 28 ec ldi r18, 0xC8 ; 200
79e: 30 e0 ldi r19, 0x00 ; 0
7a0: f9 01 movw r30, r18
7a2: 31 97 sbiw r30, 0x01 ; 1
7a4: f1 f7 brne .-4 ; 0x7a2
__ticks = (uint16_t) (__ms * 10.0);
while(__ticks)
{
// wait 1/10 ms
_delay_loop_2(((F_CPU) / 4e3) / 10);
__ticks --;
7a6: 01 97 sbiw r24, 0x01 ; 1
__ticks = 1;
else if (__tmp > 65535)
{
// __ticks = requested delay in 1/10 ms
__ticks = (uint16_t) (__ms * 10.0);
while(__ticks)
7a8: d9 f7 brne .-10 ; 0x7a0
//while(!(enc28j60Read(ESTAT) & ESTAT_CLKRDY));
// do bank 0 stuff
// initialize receive buffer
// 16-bit transfers, must write low byte first
// set receive buffer start address
NextPacketPtr = RXSTART_INIT;
7aa: 10 92 40 01 sts 0x0140, r1
7ae: 10 92 3f 01 sts 0x013F, r1
// Rx start
enc28j60Write(ERXSTL, RXSTART_INIT&0xFF);
7b2: 88 e0 ldi r24, 0x08 ; 8
7b4: 60 e0 ldi r22, 0x00 ; 0
7b6: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(ERXSTH, RXSTART_INIT>>8);
7ba: 89 e0 ldi r24, 0x09 ; 9
7bc: 60 e0 ldi r22, 0x00 ; 0
7be: 0e 94 8a 03 call 0x714 ; 0x714
// set receive pointer address
enc28j60Write(ERXRDPTL, RXSTART_INIT&0xFF);
7c2: 8c e0 ldi r24, 0x0C ; 12
7c4: 60 e0 ldi r22, 0x00 ; 0
7c6: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(ERXRDPTH, RXSTART_INIT>>8);
7ca: 8d e0 ldi r24, 0x0D ; 13
7cc: 60 e0 ldi r22, 0x00 ; 0
7ce: 0e 94 8a 03 call 0x714 ; 0x714
// RX end
enc28j60Write(ERXNDL, RXSTOP_INIT&0xFF);
7d2: 8a e0 ldi r24, 0x0A ; 10
7d4: 6e ef ldi r22, 0xFE ; 254
7d6: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(ERXNDH, RXSTOP_INIT>>8);
7da: 8b e0 ldi r24, 0x0B ; 11
7dc: 69 e1 ldi r22, 0x19 ; 25
7de: 0e 94 8a 03 call 0x714 ; 0x714
// TX start
enc28j60Write(ETXSTL, TXSTART_INIT&0xFF);
7e2: 84 e0 ldi r24, 0x04 ; 4
7e4: 6f ef ldi r22, 0xFF ; 255
7e6: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(ETXSTH, TXSTART_INIT>>8);
7ea: 85 e0 ldi r24, 0x05 ; 5
7ec: 69 e1 ldi r22, 0x19 ; 25
7ee: 0e 94 8a 03 call 0x714 ; 0x714
// TX end
enc28j60Write(ETXNDL, TXSTOP_INIT&0xFF);
7f2: 86 e0 ldi r24, 0x06 ; 6
7f4: 6f ef ldi r22, 0xFF ; 255
7f6: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(ETXNDH, TXSTOP_INIT>>8);
7fa: 87 e0 ldi r24, 0x07 ; 7
7fc: 6f e1 ldi r22, 0x1F ; 31
7fe: 0e 94 8a 03 call 0x714 ; 0x714
// Type ETH.DST
// ARP BROADCAST
// 06 08 -- ff ff ff ff ff ff -> ip checksum for theses bytes=f7f9
// in binary these poitions are:11 0000 0011 1111
// This is hex 303F->EPMM0=0x3f,EPMM1=0x30
enc28j60Write(ERXFCON, ERXFCON_UCEN|ERXFCON_CRCEN|ERXFCON_PMEN);
802: 88 e3 ldi r24, 0x38 ; 56
804: 60 eb ldi r22, 0xB0 ; 176
806: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(EPMM0, 0x3f);
80a: 88 e2 ldi r24, 0x28 ; 40
80c: 6f e3 ldi r22, 0x3F ; 63
80e: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(EPMM1, 0x30);
812: 89 e2 ldi r24, 0x29 ; 41
814: 60 e3 ldi r22, 0x30 ; 48
816: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(EPMCSL, 0xf9);
81a: 80 e3 ldi r24, 0x30 ; 48
81c: 69 ef ldi r22, 0xF9 ; 249
81e: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(EPMCSH, 0xf7);
822: 81 e3 ldi r24, 0x31 ; 49
824: 67 ef ldi r22, 0xF7 ; 247
826: 0e 94 8a 03 call 0x714 ; 0x714
//
//
// do bank 2 stuff
// enable MAC receive
enc28j60Write(MACON1, MACON1_MARXEN|MACON1_TXPAUS|MACON1_RXPAUS);
82a: 80 ec ldi r24, 0xC0 ; 192
82c: 6d e0 ldi r22, 0x0D ; 13
82e: 0e 94 8a 03 call 0x714 ; 0x714
// bring MAC out of reset
enc28j60Write(MACON2, 0x00);
832: 81 ec ldi r24, 0xC1 ; 193
834: 60 e0 ldi r22, 0x00 ; 0
836: 0e 94 8a 03 call 0x714 ; 0x714
// enable automatic padding to 60bytes and CRC operations
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, MACON3, MACON3_PADCFG0|MACON3_TXCRCEN|MACON3_FRMLNEN);
83a: 80 e8 ldi r24, 0x80 ; 128
83c: 62 ec ldi r22, 0xC2 ; 194
83e: 42 e3 ldi r20, 0x32 ; 50
840: 0e 94 1e 03 call 0x63c ; 0x63c
// set inter-frame gap (non-back-to-back)
enc28j60Write(MAIPGL, 0x12);
844: 86 ec ldi r24, 0xC6 ; 198
846: 62 e1 ldi r22, 0x12 ; 18
848: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(MAIPGH, 0x0C);
84c: 87 ec ldi r24, 0xC7 ; 199
84e: 6c e0 ldi r22, 0x0C ; 12
850: 0e 94 8a 03 call 0x714 ; 0x714
// set inter-frame gap (back-to-back)
enc28j60Write(MABBIPG, 0x12);
854: 84 ec ldi r24, 0xC4 ; 196
856: 62 e1 ldi r22, 0x12 ; 18
858: 0e 94 8a 03 call 0x714 ; 0x714
// Set the maximum packet size which the controller will accept
// Do not send packets longer than MAX_FRAMELEN:
enc28j60Write(MAMXFLL, MAX_FRAMELEN&0xFF);
85c: 8a ec ldi r24, 0xCA ; 202
85e: 68 e5 ldi r22, 0x58 ; 88
860: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(MAMXFLH, MAX_FRAMELEN>>8);
864: 8b ec ldi r24, 0xCB ; 203
866: 62 e0 ldi r22, 0x02 ; 2
868: 0e 94 8a 03 call 0x714 ; 0x714
// do bank 3 stuff
// write MAC address
// NOTE: MAC address in ENC28J60 is byte-backward
enc28j60Write(MAADR5, macaddr[0]);
86c: 84 ee ldi r24, 0xE4 ; 228
86e: 68 81 ld r22, Y
870: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(MAADR4, macaddr[1]);
874: 85 ee ldi r24, 0xE5 ; 229
876: 69 81 ldd r22, Y+1 ; 0x01
878: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(MAADR3, macaddr[2]);
87c: 82 ee ldi r24, 0xE2 ; 226
87e: 6a 81 ldd r22, Y+2 ; 0x02
880: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(MAADR2, macaddr[3]);
884: 83 ee ldi r24, 0xE3 ; 227
886: 6b 81 ldd r22, Y+3 ; 0x03
888: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(MAADR1, macaddr[4]);
88c: 80 ee ldi r24, 0xE0 ; 224
88e: 6c 81 ldd r22, Y+4 ; 0x04
890: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(MAADR0, macaddr[5]);
894: 81 ee ldi r24, 0xE1 ; 225
896: 6d 81 ldd r22, Y+5 ; 0x05
898: 0e 94 8a 03 call 0x714 ; 0x714
// no loopback of transmitted frames
enc28j60PhyWrite(PHCON2, PHCON2_HDLDIS);
89c: 80 e1 ldi r24, 0x10 ; 16
89e: 60 e0 ldi r22, 0x00 ; 0
8a0: 71 e0 ldi r23, 0x01 ; 1
8a2: 0e 94 98 03 call 0x730 ; 0x730
// switch to bank 0
enc28j60SetBank(ECON1);
8a6: 8f e1 ldi r24, 0x1F ; 31
8a8: 0e 94 5c 03 call 0x6b8 ; 0x6b8
// enable interrutps
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, EIE, EIE_INTIE|EIE_PKTIE);
8ac: 80 e8 ldi r24, 0x80 ; 128
8ae: 6b e1 ldi r22, 0x1B ; 27
8b0: 40 ec ldi r20, 0xC0 ; 192
8b2: 0e 94 1e 03 call 0x63c ; 0x63c
// enable packet reception
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_RXEN);
8b6: 80 e8 ldi r24, 0x80 ; 128
8b8: 6f e1 ldi r22, 0x1F ; 31
8ba: 44 e0 ldi r20, 0x04 ; 4
8bc: 0e 94 1e 03 call 0x63c ; 0x63c
}
8c0: df 91 pop r29
8c2: cf 91 pop r28
8c4: 08 95 ret
000008c6 :
// read the revision of the chip:
uint8_t enc28j60getrev(void)
{
return(enc28j60Read(EREVID));
8c6: 82 e7 ldi r24, 0x72 ; 114
8c8: 0e 94 80 03 call 0x700 ; 0x700
}
8cc: 08 95 ret
000008ce :
void enc28j60PacketSend(uint16_t len, uint8_t* packet)
{
8ce: ef 92 push r14
8d0: ff 92 push r15
8d2: 0f 93 push r16
8d4: 1f 93 push r17
8d6: 8c 01 movw r16, r24
8d8: 7b 01 movw r14, r22
// Set the write pointer to start of transmit buffer area
enc28j60Write(EWRPTL, TXSTART_INIT&0xFF);
8da: 82 e0 ldi r24, 0x02 ; 2
8dc: 6f ef ldi r22, 0xFF ; 255
8de: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(EWRPTH, TXSTART_INIT>>8);
8e2: 83 e0 ldi r24, 0x03 ; 3
8e4: 69 e1 ldi r22, 0x19 ; 25
8e6: 0e 94 8a 03 call 0x714 ; 0x714
// Set the TXND pointer to correspond to the packet size given
enc28j60Write(ETXNDL, (TXSTART_INIT+len)&0xFF);
8ea: 60 2f mov r22, r16
8ec: 61 50 subi r22, 0x01 ; 1
8ee: 86 e0 ldi r24, 0x06 ; 6
8f0: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(ETXNDH, (TXSTART_INIT+len)>>8);
8f4: 98 01 movw r18, r16
8f6: 21 50 subi r18, 0x01 ; 1
8f8: 36 4e sbci r19, 0xE6 ; 230
8fa: 87 e0 ldi r24, 0x07 ; 7
8fc: 63 2f mov r22, r19
8fe: 0e 94 8a 03 call 0x714 ; 0x714
// write per-packet control byte (0x00 means use macon3 settings)
enc28j60WriteOp(ENC28J60_WRITE_BUF_MEM, 0, 0x00);
902: 8a e7 ldi r24, 0x7A ; 122
904: 60 e0 ldi r22, 0x00 ; 0
906: 40 e0 ldi r20, 0x00 ; 0
908: 0e 94 1e 03 call 0x63c ; 0x63c
// copy the packet into the transmit buffer
enc28j60WriteBuffer(len, packet);
90c: c8 01 movw r24, r16
90e: b7 01 movw r22, r14
910: 0e 94 46 03 call 0x68c ; 0x68c
// send the contents of the transmit buffer onto the network
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_TXRTS);
914: 80 e8 ldi r24, 0x80 ; 128
916: 6f e1 ldi r22, 0x1F ; 31
918: 48 e0 ldi r20, 0x08 ; 8
91a: 0e 94 1e 03 call 0x63c ; 0x63c
// Reset the transmit logic problem. See Rev. B4 Silicon Errata point 12.
if( (enc28j60Read(EIR) & EIR_TXERIF) ){
91e: 8c e1 ldi r24, 0x1C ; 28
920: 0e 94 80 03 call 0x700 ; 0x700
924: 81 ff sbrs r24, 1
926: 05 c0 rjmp .+10 ; 0x932
enc28j60WriteOp(ENC28J60_BIT_FIELD_CLR, ECON1, ECON1_TXRTS);
928: 80 ea ldi r24, 0xA0 ; 160
92a: 6f e1 ldi r22, 0x1F ; 31
92c: 48 e0 ldi r20, 0x08 ; 8
92e: 0e 94 1e 03 call 0x63c ; 0x63c
}
}
932: 1f 91 pop r17
934: 0f 91 pop r16
936: ff 90 pop r15
938: ef 90 pop r14
93a: 08 95 ret
0000093c :
buf[TCP_CHECKSUM_H_P]=j>>8;
buf[TCP_CHECKSUM_L_P]=j& 0xff;
enc28j60PacketSend(IP_HEADER_LEN+TCP_HEADER_LEN_PLAIN+ETH_HEADER_LEN,buf);
}
void make_tcp_ack_with_data(uint8_t *buf,uint16_t dlen)
{
93c: ef 92 push r14
93e: ff 92 push r15
940: 0f 93 push r16
942: 1f 93 push r17
944: 8c 01 movw r16, r24
946: 7b 01 movw r14, r22
uint16_t j;
buf[TCP_FLAGS_P]=TCP_FLAGS_ACK_V|TCP_FLAGS_PUSH_V|TCP_FLAGS_FIN_V;
948: 89 e1 ldi r24, 0x19 ; 25
94a: f8 01 movw r30, r16
94c: 87 a7 std Z+47, r24 ; 0x2f
j=IP_HEADER_LEN+TCP_HEADER_LEN_PLAIN+dlen;
94e: cb 01 movw r24, r22
950: 88 96 adiw r24, 0x28 ; 40
buf[IP_TOTLEN_H_P]=j>>8;
952: 90 8b std Z+16, r25 ; 0x10
buf[IP_TOTLEN_L_P]=j& 0xff;
954: 81 8b std Z+17, r24 ; 0x11
fill_ip_hdr_checksum(buf);
956: c8 01 movw r24, r16
958: 0e 94 4c 02 call 0x498 ; 0x498
buf[TCP_CHECKSUM_H_P]=0;
95c: f8 01 movw r30, r16
95e: 12 aa std Z+50, r1 ; 0x32
buf[TCP_CHECKSUM_L_P]=0;
960: 13 aa std Z+51, r1 ; 0x33
j=checksum(&buf[IP_SRC_P], 8+TCP_HEADER_LEN_PLAIN+dlen,2);
962: 8c e1 ldi r24, 0x1C ; 28
964: 90 e0 ldi r25, 0x00 ; 0
966: e8 0e add r14, r24
968: f9 1e adc r15, r25
96a: c8 01 movw r24, r16
96c: 4a 96 adiw r24, 0x1a ; 26
96e: b7 01 movw r22, r14
970: 42 e0 ldi r20, 0x02 ; 2
972: 0e 94 83 01 call 0x306 ; 0x306
buf[TCP_CHECKSUM_H_P]=j>>8;
976: f8 01 movw r30, r16
978: 92 ab std Z+50, r25 ; 0x32
buf[TCP_CHECKSUM_L_P]=j& 0xff;
97a: 83 ab std Z+51, r24 ; 0x33
enc28j60PacketSend(IP_HEADER_LEN+TCP_HEADER_LEN_PLAIN+dlen+ETH_HEADER_LEN,buf);
97c: c7 01 movw r24, r14
97e: 4a 96 adiw r24, 0x1a ; 26
980: b8 01 movw r22, r16
982: 0e 94 67 04 call 0x8ce ; 0x8ce
}
986: 1f 91 pop r17
988: 0f 91 pop r16
98a: ff 90 pop r15
98c: ef 90 pop r14
98e: 08 95 ret
00000990 :
s++;
}
return(pos);
}
void make_tcp_ack_from_any(uint8_t *buf)// функция генерации подтверждения любого запроса
{
990: cf 93 push r28
992: df 93 push r29
994: ec 01 movw r28, r24
uint16_t j;
make_eth(buf);
996: 0e 94 3f 02 call 0x47e ; 0x47e
buf[TCP_FLAGS_P]=TCP_FLAGS_ACK_V;
99a: 80 e1 ldi r24, 0x10 ; 16
99c: 8f a7 std Y+47, r24 ; 0x2f
if (info_data_len==0)
99e: 60 91 30 01 lds r22, 0x0130
9a2: 70 91 31 01 lds r23, 0x0131
9a6: 61 15 cp r22, r1
9a8: 71 05 cpc r23, r1
9aa: 21 f4 brne .+8 ; 0x9b4
{
make_tcphead(buf,1,0,1);
9ac: ce 01 movw r24, r28
9ae: 61 e0 ldi r22, 0x01 ; 1
9b0: 70 e0 ldi r23, 0x00 ; 0
9b2: 01 c0 rjmp .+2 ; 0x9b6
}
else
{
make_tcphead(buf,info_data_len,0,1);
9b4: ce 01 movw r24, r28
9b6: 40 e0 ldi r20, 0x00 ; 0
9b8: 21 e0 ldi r18, 0x01 ; 1
9ba: 0e 94 74 02 call 0x4e8 ; 0x4e8
}
j=IP_HEADER_LEN+TCP_HEADER_LEN_PLAIN;
buf[IP_TOTLEN_H_P]=j>>8;
9be: 18 8a std Y+16, r1 ; 0x10
buf[IP_TOTLEN_L_P]=j& 0xff;
9c0: 88 e2 ldi r24, 0x28 ; 40
9c2: 89 8b std Y+17, r24 ; 0x11
make_ip(buf);
9c4: ce 01 movw r24, r28
9c6: 0e 94 63 02 call 0x4c6 ; 0x4c6
j=checksum(&buf[IP_SRC_P], 8+TCP_HEADER_LEN_PLAIN,2);
9ca: ce 01 movw r24, r28
9cc: 4a 96 adiw r24, 0x1a ; 26
9ce: 6c e1 ldi r22, 0x1C ; 28
9d0: 70 e0 ldi r23, 0x00 ; 0
9d2: 42 e0 ldi r20, 0x02 ; 2
9d4: 0e 94 83 01 call 0x306 ; 0x306
buf[TCP_CHECKSUM_H_P]=j>>8;
9d8: 9a ab std Y+50, r25 ; 0x32
buf[TCP_CHECKSUM_L_P]=j& 0xff;
9da: 8b ab std Y+51, r24 ; 0x33
enc28j60PacketSend(IP_HEADER_LEN+TCP_HEADER_LEN_PLAIN+ETH_HEADER_LEN,buf);
9dc: 86 e3 ldi r24, 0x36 ; 54
9de: 90 e0 ldi r25, 0x00 ; 0
9e0: be 01 movw r22, r28
9e2: 0e 94 67 04 call 0x8ce ; 0x8ce
}
9e6: df 91 pop r29
9e8: cf 91 pop r28
9ea: 08 95 ret
000009ec :
buf[TCP_HEADER_LEN_P]=0x50;
}
}
void make_tcp_synack_from_syn(uint8_t *buf)//функция отправки подтверждения открытия соединения
{
9ec: 0f 93 push r16
9ee: 1f 93 push r17
9f0: 8c 01 movw r16, r24
uint16_t ck;
make_eth(buf);
9f2: 0e 94 3f 02 call 0x47e ; 0x47e
buf[IP_TOTLEN_H_P]=0;
9f6: f8 01 movw r30, r16
9f8: 10 8a std Z+16, r1 ; 0x10
buf[IP_TOTLEN_L_P]=IP_HEADER_LEN+TCP_HEADER_LEN_PLAIN+4;
9fa: 8c e2 ldi r24, 0x2C ; 44
9fc: 81 8b std Z+17, r24 ; 0x11
make_ip(buf);
9fe: c8 01 movw r24, r16
a00: 0e 94 63 02 call 0x4c6 ; 0x4c6
buf[TCP_FLAGS_P]=TCP_FLAGS_SYNACK_V;
a04: 82 e1 ldi r24, 0x12 ; 18
a06: f8 01 movw r30, r16
a08: 87 a7 std Z+47, r24 ; 0x2f
make_tcphead(buf,1,1,0);
a0a: c8 01 movw r24, r16
a0c: 61 e0 ldi r22, 0x01 ; 1
a0e: 70 e0 ldi r23, 0x00 ; 0
a10: 41 e0 ldi r20, 0x01 ; 1
a12: 20 e0 ldi r18, 0x00 ; 0
a14: 0e 94 74 02 call 0x4e8 ; 0x4e8
ck=checksum(&buf[IP_SRC_P], 8+TCP_HEADER_LEN_PLAIN+4,2);
a18: c8 01 movw r24, r16
a1a: 4a 96 adiw r24, 0x1a ; 26
a1c: 60 e2 ldi r22, 0x20 ; 32
a1e: 70 e0 ldi r23, 0x00 ; 0
a20: 42 e0 ldi r20, 0x02 ; 2
a22: 0e 94 83 01 call 0x306 ; 0x306
buf[TCP_CHECKSUM_H_P]=ck>>8;
a26: f8 01 movw r30, r16
a28: 92 ab std Z+50, r25 ; 0x32
buf[TCP_CHECKSUM_L_P]=ck& 0xff;
a2a: 83 ab std Z+51, r24 ; 0x33
enc28j60PacketSend(IP_HEADER_LEN+TCP_HEADER_LEN_PLAIN+4+ETH_HEADER_LEN,buf);
a2c: 8a e3 ldi r24, 0x3A ; 58
a2e: 90 e0 ldi r25, 0x00 ; 0
a30: b8 01 movw r22, r16
a32: 0e 94 67 04 call 0x8ce ; 0x8ce
}
a36: 1f 91 pop r17
a38: 0f 91 pop r16
a3a: 08 95 ret
00000a3c :
enc28j60PacketSend(42,buf);
}
void make_echo_reply_from_request(uint8_t *buf,uint16_t len)// функция генерации понг-ответа для отправления
{
a3c: 0f 93 push r16
a3e: 1f 93 push r17
a40: cf 93 push r28
a42: df 93 push r29
a44: ec 01 movw r28, r24
a46: 8b 01 movw r16, r22
make_eth(buf);
a48: 0e 94 3f 02 call 0x47e ; 0x47e
make_ip(buf);
a4c: ce 01 movw r24, r28
a4e: 0e 94 63 02 call 0x4c6 ; 0x4c6
buf[ICMP_TYPE_P]=ICMP_TYPE_ECHOREPLY_V;
a52: 1a a2 std Y+34, r1 ; 0x22
if (buf[ICMP_CHECKSUM_P] > (0xff-0x08)){
a54: 8c a1 ldd r24, Y+36 ; 0x24
a56: 88 3f cpi r24, 0xF8 ; 248
a58: 18 f0 brcs .+6 ; 0xa60
buf[ICMP_CHECKSUM_P+1]++;
a5a: 8d a1 ldd r24, Y+37 ; 0x25
a5c: 8f 5f subi r24, 0xFF ; 255
a5e: 8d a3 std Y+37, r24 ; 0x25
}
buf[ICMP_CHECKSUM_P]+=0x08;
a60: 8c a1 ldd r24, Y+36 ; 0x24
a62: 88 5f subi r24, 0xF8 ; 248
a64: 8c a3 std Y+36, r24 ; 0x24
//
enc28j60PacketSend(len,buf);
a66: c8 01 movw r24, r16
a68: be 01 movw r22, r28
a6a: 0e 94 67 04 call 0x8ce ; 0x8ce
}
a6e: df 91 pop r29
a70: cf 91 pop r28
a72: 1f 91 pop r17
a74: 0f 91 pop r16
a76: 08 95 ret
00000a78 :
fill_ip_hdr_checksum(buf);
}
void make_arp_answer_from_request(uint8_t *buf)// функция генерации ARP-ответа для отправления
{
a78: cf 93 push r28
a7a: df 93 push r29
a7c: ec 01 movw r28, r24
uint8_t i=0;
make_eth(buf);
a7e: 0e 94 3f 02 call 0x47e ; 0x47e
buf[ETH_ARP_OPCODE_H_P]=ETH_ARP_OPCODE_REPLY_H_V;
a82: 1c 8a std Y+20, r1 ; 0x14
buf[ETH_ARP_OPCODE_L_P]=ETH_ARP_OPCODE_REPLY_L_V;
a84: 82 e0 ldi r24, 0x02 ; 2
a86: 8d 8b std Y+21, r24 ; 0x15
a88: fe 01 movw r30, r28
a8a: a4 e3 ldi r26, 0x34 ; 52
a8c: b1 e0 ldi r27, 0x01 ; 1
while(i<6){
buf[ETH_ARP_DST_MAC_P+i]=buf[ETH_ARP_SRC_MAC_P+i];
a8e: 86 89 ldd r24, Z+22 ; 0x16
a90: 80 a3 std Z+32, r24 ; 0x20
buf[ETH_ARP_SRC_MAC_P+i]=macaddr[i];
a92: 8d 91 ld r24, X+
a94: 86 8b std Z+22, r24 ; 0x16
a96: 31 96 adiw r30, 0x01 ; 1
make_eth(buf);
buf[ETH_ARP_OPCODE_H_P]=ETH_ARP_OPCODE_REPLY_H_V;
buf[ETH_ARP_OPCODE_L_P]=ETH_ARP_OPCODE_REPLY_L_V;
while(i<6){
a98: 81 e0 ldi r24, 0x01 ; 1
a9a: aa 33 cpi r26, 0x3A ; 58
a9c: b8 07 cpc r27, r24
a9e: b9 f7 brne .-18 ; 0xa8e
aa0: fe 01 movw r30, r28
aa2: 7c 96 adiw r30, 0x1c ; 28
aa4: aa e3 ldi r26, 0x3A ; 58
aa6: b1 e0 ldi r27, 0x01 ; 1
buf[ETH_ARP_SRC_MAC_P+i]=macaddr[i];
i++;
}
i=0;
while(i<4){
buf[ETH_ARP_DST_IP_P+i]=buf[ETH_ARP_SRC_IP_P+i];
aa8: 80 81 ld r24, Z
aaa: 82 87 std Z+10, r24 ; 0x0a
buf[ETH_ARP_SRC_IP_P+i]=ipaddr[i];
aac: 8d 91 ld r24, X+
aae: 81 93 st Z+, r24
buf[ETH_ARP_DST_MAC_P+i]=buf[ETH_ARP_SRC_MAC_P+i];
buf[ETH_ARP_SRC_MAC_P+i]=macaddr[i];
i++;
}
i=0;
while(i<4){
ab0: 81 e0 ldi r24, 0x01 ; 1
ab2: ae 33 cpi r26, 0x3E ; 62
ab4: b8 07 cpc r27, r24
ab6: c1 f7 brne .-16 ; 0xaa8
buf[ETH_ARP_DST_IP_P+i]=buf[ETH_ARP_SRC_IP_P+i];
buf[ETH_ARP_SRC_IP_P+i]=ipaddr[i];
i++;
}
enc28j60PacketSend(42,buf);
ab8: 8a e2 ldi r24, 0x2A ; 42
aba: 90 e0 ldi r25, 0x00 ; 0
abc: be 01 movw r22, r28
abe: 0e 94 67 04 call 0x8ce ; 0x8ce
}
ac2: df 91 pop r29
ac4: cf 91 pop r28
ac6: 08 95 ret
00000ac8 :
// The packet will by headed by an ethernet header.
// maxlen The maximum acceptable length of a retrieved packet.
// packet Pointer where packet data should be stored.
// Returns: Packet length in bytes if a packet was retrieved, zero otherwise.
uint16_t enc28j60PacketReceive(uint16_t maxlen, uint8_t* packet)
{
ac8: af 92 push r10
aca: bf 92 push r11
acc: cf 92 push r12
ace: df 92 push r13
ad0: ef 92 push r14
ad2: ff 92 push r15
ad4: 0f 93 push r16
ad6: 1f 93 push r17
ad8: cf 93 push r28
ada: df 93 push r29
adc: 6c 01 movw r12, r24
ade: 5b 01 movw r10, r22
uint16_t rxstat;
uint16_t len;
// check if a packet has been received and buffered
//if( !(enc28j60Read(EIR) & EIR_PKTIF) ){
// The above does not work. See Rev. B4 Silicon Errata point 6.
if( enc28j60Read(EPKTCNT) ==0 ){
ae0: 89 e3 ldi r24, 0x39 ; 57
ae2: 0e 94 80 03 call 0x700 ; 0x700
ae6: 88 23 and r24, r24
ae8: 19 f4 brne .+6 ; 0xaf0
aea: 00 e0 ldi r16, 0x00 ; 0
aec: 10 e0 ldi r17, 0x00 ; 0
aee: 5a c0 rjmp .+180 ; 0xba4
return(0);
}
// Set the read pointer to the start of the received packet
enc28j60Write(ERDPTL, (NextPacketPtr));
af0: 60 91 3f 01 lds r22, 0x013F
af4: 10 91 40 01 lds r17, 0x0140
af8: 80 e0 ldi r24, 0x00 ; 0
afa: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(ERDPTH, (NextPacketPtr)>>8);
afe: 81 e0 ldi r24, 0x01 ; 1
b00: 61 2f mov r22, r17
b02: 0e 94 8a 03 call 0x714 ; 0x714
// read the next packet pointer
NextPacketPtr = enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0);
b06: 8a e3 ldi r24, 0x3A ; 58
b08: 60 e0 ldi r22, 0x00 ; 0
b0a: 0e 94 09 03 call 0x612 ; 0x612
b0e: 18 2f mov r17, r24
NextPacketPtr |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8;
b10: 8a e3 ldi r24, 0x3A ; 58
b12: 60 e0 ldi r22, 0x00 ; 0
b14: 0e 94 09 03 call 0x612 ; 0x612
b18: 38 2f mov r19, r24
b1a: 20 e0 ldi r18, 0x00 ; 0
b1c: c1 2f mov r28, r17
b1e: d0 e0 ldi r29, 0x00 ; 0
b20: c2 2b or r28, r18
b22: d3 2b or r29, r19
b24: d0 93 40 01 sts 0x0140, r29
b28: c0 93 3f 01 sts 0x013F, r28
// read the packet length (see datasheet page 43)
len = enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0);
b2c: 8a e3 ldi r24, 0x3A ; 58
b2e: 60 e0 ldi r22, 0x00 ; 0
b30: 0e 94 09 03 call 0x612 ; 0x612
b34: e8 2e mov r14, r24
len |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8;
b36: 8a e3 ldi r24, 0x3A ; 58
b38: 60 e0 ldi r22, 0x00 ; 0
b3a: 0e 94 09 03 call 0x612 ; 0x612
b3e: f8 2e mov r15, r24
len-=4; //remove the CRC count
// read the receive status (see datasheet page 43)
rxstat = enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0);
b40: 8a e3 ldi r24, 0x3A ; 58
b42: 60 e0 ldi r22, 0x00 ; 0
b44: 0e 94 09 03 call 0x612 ; 0x612
b48: 08 2f mov r16, r24
b4a: 10 e0 ldi r17, 0x00 ; 0
rxstat |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8;
b4c: 8a e3 ldi r24, 0x3A ; 58
b4e: 60 e0 ldi r22, 0x00 ; 0
b50: 0e 94 09 03 call 0x612 ; 0x612
len=maxlen-1;
}
// check CRC and symbol errors (see datasheet page 44, table 7-3):
// The ERXFCON.CRCEN is set by default. Normally we should not
// need to check this.
if ((rxstat & 0x80)==0){
b54: 38 2f mov r19, r24
b56: 20 e0 ldi r18, 0x00 ; 0
b58: 20 2b or r18, r16
b5a: 31 2b or r19, r17
b5c: 27 fd sbrc r18, 7
b5e: 03 c0 rjmp .+6 ; 0xb66
b60: 00 e0 ldi r16, 0x00 ; 0
b62: 10 e0 ldi r17, 0x00 ; 0
b64: 12 c0 rjmp .+36 ; 0xb8a
enc28j60Write(ERDPTH, (NextPacketPtr)>>8);
// read the next packet pointer
NextPacketPtr = enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0);
NextPacketPtr |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8;
// read the packet length (see datasheet page 43)
len = enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0);
b66: 0e 2d mov r16, r14
b68: 10 e0 ldi r17, 0x00 ; 0
len |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8;
b6a: 9f 2d mov r25, r15
b6c: 80 e0 ldi r24, 0x00 ; 0
b6e: 08 2b or r16, r24
b70: 19 2b or r17, r25
len-=4; //remove the CRC count
b72: c6 01 movw r24, r12
b74: 01 97 sbiw r24, 0x01 ; 1
b76: 04 50 subi r16, 0x04 ; 4
b78: 10 40 sbci r17, 0x00 ; 0
b7a: 80 17 cp r24, r16
b7c: 91 07 cpc r25, r17
b7e: 08 f4 brcc .+2 ; 0xb82
b80: 8c 01 movw r16, r24
if ((rxstat & 0x80)==0){
// invalid
len=0;
}else{
// copy the packet from the receive buffer
enc28j60ReadBuffer(len, packet);
b82: c8 01 movw r24, r16
b84: b5 01 movw r22, r10
b86: 0e 94 2b 03 call 0x656 ; 0x656
}
// Move the RX read pointer to the start of the next received packet
// This frees the memory we just read out
enc28j60Write(ERXRDPTL, (NextPacketPtr));
b8a: 8c e0 ldi r24, 0x0C ; 12
b8c: 6c 2f mov r22, r28
b8e: 0e 94 8a 03 call 0x714 ; 0x714
enc28j60Write(ERXRDPTH, (NextPacketPtr)>>8);
b92: 8d e0 ldi r24, 0x0D ; 13
b94: 6d 2f mov r22, r29
b96: 0e 94 8a 03 call 0x714 ; 0x714
// decrement the packet counter indicate we are done with this packet
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON2, ECON2_PKTDEC);
b9a: 80 e8 ldi r24, 0x80 ; 128
b9c: 6e e1 ldi r22, 0x1E ; 30
b9e: 40 e4 ldi r20, 0x40 ; 64
ba0: 0e 94 1e 03 call 0x63c ; 0x63c
return(len);
}
ba4: c8 01 movw r24, r16
ba6: df 91 pop r29
ba8: cf 91 pop r28
baa: 1f 91 pop r17
bac: 0f 91 pop r16
bae: ff 90 pop r15
bb0: ef 90 pop r14
bb2: df 90 pop r13
bb4: cf 90 pop r12
bb6: bf 90 pop r11
bb8: af 90 pop r10
bba: 08 95 ret
00000bbc :
return(*str-0x30);//возвратим значение этого числа числа в прямом виде
}
return(-2);// если пароль верный, но нет команды после него, то возвращает -2
}
uint16_t print_webpage(uint8_t *buf,uint8_t on_off)// записывает в буфер страницу для отправки
{
bbc: dc 01 movw r26, r24
bbe: d6 96 adiw r26, 0x36 ; 54
bc0: 20 e0 ldi r18, 0x00 ; 0
bc2: 30 e0 ldi r19, 0x00 ; 0
bc4: 03 c0 rjmp .+6 ; 0xbcc
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
bc6: 4d 93 st X+, r20
pos++;
bc8: 2f 5f subi r18, 0xFF ; 255
bca: 3f 4f sbci r19, 0xFF ; 255
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
bcc: f9 01 movw r30, r18
bce: e5 56 subi r30, 0x65 ; 101
bd0: fd 4f sbci r31, 0xFD ; 253
bd2: 44 91 lpm r20, Z+
bd4: 44 23 and r20, r20
bd6: b9 f7 brne .-18 ; 0xbc6
bd8: 2a 5c subi r18, 0xCA ; 202
bda: 3f 4f sbci r19, 0xFF ; 255
bdc: dc 01 movw r26, r24
bde: a2 0f add r26, r18
be0: b3 1f adc r27, r19
be2: 26 53 subi r18, 0x36 ; 54
be4: 30 40 sbci r19, 0x00 ; 0
uint16_t plen;
plen=fill_tcp_data_p(buf,0,PSTR("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n"));
plen=fill_tcp_data_p(buf,plen,PSTR("УПРАВЛЕНИЕ И МОНИТОРИНГ СОСТОЯНИЯ СВЕТОДИОДА"));
be6: 48 e5 ldi r20, 0x58 ; 88
be8: 52 e0 ldi r21, 0x02 ; 2
bea: 03 c0 rjmp .+6 ; 0xbf2
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
bec: 7d 93 st X+, r23
pos++;
bee: 2f 5f subi r18, 0xFF ; 255
bf0: 3f 4f sbci r19, 0xFF ; 255
bf2: fa 01 movw r30, r20
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
bf4: 4f 5f subi r20, 0xFF ; 255
bf6: 5f 4f sbci r21, 0xFF ; 255
bf8: 74 91 lpm r23, Z+
bfa: 77 23 and r23, r23
bfc: b9 f7 brne .-18 ; 0xbec
bfe: 2a 5c subi r18, 0xCA ; 202
c00: 3f 4f sbci r19, 0xFF ; 255
c02: dc 01 movw r26, r24
c04: a2 0f add r26, r18
c06: b3 1f adc r27, r19
c08: 26 53 subi r18, 0x36 ; 54
c0a: 30 40 sbci r19, 0x00 ; 0
plen=fill_tcp_data_p(buf,plen,PSTR("Диод: "));
c0c: 49 e2 ldi r20, 0x29 ; 41
c0e: 52 e0 ldi r21, 0x02 ; 2
c10: 03 c0 rjmp .+6 ; 0xc18
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
c12: 7d 93 st X+, r23
pos++;
c14: 2f 5f subi r18, 0xFF ; 255
c16: 3f 4f sbci r19, 0xFF ; 255
c18: fa 01 movw r30, r20
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
c1a: 4f 5f subi r20, 0xFF ; 255
c1c: 5f 4f sbci r21, 0xFF ; 255
c1e: 74 91 lpm r23, Z+
c20: 77 23 and r23, r23
c22: b9 f7 brne .-18 ; 0xc12
c24: a9 01 movw r20, r18
c26: 4a 5c subi r20, 0xCA ; 202
c28: 5f 4f sbci r21, 0xFF ; 255
if (on_off)
c2a: 66 23 and r22, r22
c2c: 31 f4 brne .+12 ; 0xc3a
c2e: dc 01 movw r26, r24
c30: a4 0f add r26, r20
c32: b5 1f adc r27, r21
{
plen=fill_tcp_data_p(buf,plen,PSTR(" Включен"));
}
else
{
plen=fill_tcp_data_p(buf,plen,PSTR("Выключен"));
c34: 4a ef ldi r20, 0xFA ; 250
c36: 51 e0 ldi r21, 0x01 ; 1
c38: 1c c0 rjmp .+56 ; 0xc72
c3a: dc 01 movw r26, r24
c3c: a4 0f add r26, r20
c3e: b5 1f adc r27, r21
plen=fill_tcp_data_p(buf,0,PSTR("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n"));
plen=fill_tcp_data_p(buf,plen,PSTR("УПРАВЛЕНИЕ И МОНИТОРИНГ СОСТОЯНИЯ СВЕТОДИОДА"));
plen=fill_tcp_data_p(buf,plen,PSTR("Диод: "));
if (on_off)
{
plen=fill_tcp_data_p(buf,plen,PSTR(" Включен"));
c40: 43 e0 ldi r20, 0x03 ; 3
c42: 52 e0 ldi r21, 0x02 ; 2
c44: 03 c0 rjmp .+6 ; 0xc4c
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
c46: 7d 93 st X+, r23
pos++;
c48: 2f 5f subi r18, 0xFF ; 255
c4a: 3f 4f sbci r19, 0xFF ; 255
c4c: fa 01 movw r30, r20
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
c4e: 4f 5f subi r20, 0xFF ; 255
c50: 5f 4f sbci r21, 0xFF ; 255
c52: 74 91 lpm r23, Z+
c54: 77 23 and r23, r23
c56: b9 f7 brne .-18 ; 0xc46
c58: 2a 5c subi r18, 0xCA ; 202
c5a: 3f 4f sbci r19, 0xFF ; 255
c5c: dc 01 movw r26, r24
c5e: a2 0f add r26, r18
c60: b3 1f adc r27, r19
c62: 26 53 subi r18, 0x36 ; 54
c64: 30 40 sbci r19, 0x00 ; 0
}
else
{
plen=fill_tcp_data_p(buf,plen,PSTR("Выключен"));
}
plen=fill_tcp_data_p(buf,plen,PSTR("
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
c6c: 7d 93 st X+, r23
pos++;
c6e: 2f 5f subi r18, 0xFF ; 255
c70: 3f 4f sbci r19, 0xFF ; 255
c72: fa 01 movw r30, r20
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
c74: 4f 5f subi r20, 0xFF ; 255
c76: 5f 4f sbci r21, 0xFF ; 255
c78: 74 91 lpm r23, Z+
c7a: 77 23 and r23, r23
c7c: b9 f7 brne .-18 ; 0xc6c
c7e: ec cf rjmp .-40 ; 0xc58
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
c80: 7d 93 st X+, r23
pos++;
c82: 2f 5f subi r18, 0xFF ; 255
c84: 3f 4f sbci r19, 0xFF ; 255
c86: fa 01 movw r30, r20
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
c88: 4f 5f subi r20, 0xFF ; 255
c8a: 5f 4f sbci r21, 0xFF ; 255
c8c: 74 91 lpm r23, Z+
c8e: 77 23 and r23, r23
c90: b9 f7 brne .-18 ; 0xc80
c92: 2a 5c subi r18, 0xCA ; 202
c94: 3f 4f sbci r19, 0xFF ; 255
c96: dc 01 movw r26, r24
c98: a2 0f add r26, r18
c9a: b3 1f adc r27, r19
c9c: 26 53 subi r18, 0x36 ; 54
c9e: 30 40 sbci r19, 0x00 ; 0
ca0: e2 e1 ldi r30, 0x12 ; 18
ca2: f1 e0 ldi r31, 0x01 ; 1
ca4: 04 c0 rjmp .+8 ; 0xcae
}
uint16_t fill_tcp_data(uint8_t *buf,uint16_t pos, const char *s)//функция записи строковых данных в буфер
{
while (*s)
{
buf[TCP_CHECKSUM_L_P+3+pos]=*s;
ca6: 4d 93 st X+, r20
pos++;
ca8: 2f 5f subi r18, 0xFF ; 255
caa: 3f 4f sbci r19, 0xFF ; 255
s++;
cac: 31 96 adiw r30, 0x01 ; 1
}
return(pos);
}
uint16_t fill_tcp_data(uint8_t *buf,uint16_t pos, const char *s)//функция записи строковых данных в буфер
{
while (*s)
cae: 40 81 ld r20, Z
cb0: 44 23 and r20, r20
cb2: c9 f7 brne .-14 ; 0xca6
cb4: 2a 5c subi r18, 0xCA ; 202
cb6: 3f 4f sbci r19, 0xFF ; 255
cb8: dc 01 movw r26, r24
cba: a2 0f add r26, r18
cbc: b3 1f adc r27, r19
cbe: 26 53 subi r18, 0x36 ; 54
cc0: 30 40 sbci r19, 0x00 ; 0
cc2: e7 e2 ldi r30, 0x27 ; 39
cc4: f1 e0 ldi r31, 0x01 ; 1
cc6: 04 c0 rjmp .+8 ; 0xcd0
{
buf[TCP_CHECKSUM_L_P+3+pos]=*s;
cc8: 4d 93 st X+, r20
pos++;
cca: 2f 5f subi r18, 0xFF ; 255
ccc: 3f 4f sbci r19, 0xFF ; 255
s++;
cce: 31 96 adiw r30, 0x01 ; 1
}
return(pos);
}
uint16_t fill_tcp_data(uint8_t *buf,uint16_t pos, const char *s)//функция записи строковых данных в буфер
{
while (*s)
cd0: 40 81 ld r20, Z
cd2: 44 23 and r20, r20
cd4: c9 f7 brne .-14 ; 0xcc8
cd6: 2a 5c subi r18, 0xCA ; 202
cd8: 3f 4f sbci r19, 0xFF ; 255
cda: dc 01 movw r26, r24
cdc: a2 0f add r26, r18
cde: b3 1f adc r27, r19
ce0: 26 53 subi r18, 0x36 ; 54
ce2: 30 40 sbci r19, 0x00 ; 0
plen=fill_tcp_data(buf,plen,baseurl);
plen=fill_tcp_data(buf,plen,password);
plen=fill_tcp_data_p(buf,plen,PSTR("\">[Проверить состояние]
\n
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
cea: 7d 93 st X+, r23
pos++;
cec: 2f 5f subi r18, 0xFF ; 255
cee: 3f 4f sbci r19, 0xFF ; 255
cf0: fa 01 movw r30, r20
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
cf2: 4f 5f subi r20, 0xFF ; 255
cf4: 5f 4f sbci r21, 0xFF ; 255
cf6: 74 91 lpm r23, Z+
cf8: 77 23 and r23, r23
cfa: b9 f7 brne .-18 ; 0xcea
cfc: 2a 5c subi r18, 0xCA ; 202
cfe: 3f 4f sbci r19, 0xFF ; 255
d00: dc 01 movw r26, r24
d02: a2 0f add r26, r18
d04: b3 1f adc r27, r19
d06: 26 53 subi r18, 0x36 ; 54
d08: 30 40 sbci r19, 0x00 ; 0
d0a: e2 e1 ldi r30, 0x12 ; 18
d0c: f1 e0 ldi r31, 0x01 ; 1
d0e: 04 c0 rjmp .+8 ; 0xd18
}
uint16_t fill_tcp_data(uint8_t *buf,uint16_t pos, const char *s)//функция записи строковых данных в буфер
{
while (*s)
{
buf[TCP_CHECKSUM_L_P+3+pos]=*s;
d10: 4d 93 st X+, r20
pos++;
d12: 2f 5f subi r18, 0xFF ; 255
d14: 3f 4f sbci r19, 0xFF ; 255
s++;
d16: 31 96 adiw r30, 0x01 ; 1
}
return(pos);
}
uint16_t fill_tcp_data(uint8_t *buf,uint16_t pos, const char *s)//функция записи строковых данных в буфер
{
while (*s)
d18: 40 81 ld r20, Z
d1a: 44 23 and r20, r20
d1c: c9 f7 brne .-14 ; 0xd10
d1e: 2a 5c subi r18, 0xCA ; 202
d20: 3f 4f sbci r19, 0xFF ; 255
d22: dc 01 movw r26, r24
d24: a2 0f add r26, r18
d26: b3 1f adc r27, r19
d28: 26 53 subi r18, 0x36 ; 54
d2a: 30 40 sbci r19, 0x00 ; 0
d2c: e7 e2 ldi r30, 0x27 ; 39
d2e: f1 e0 ldi r31, 0x01 ; 1
d30: 04 c0 rjmp .+8 ; 0xd3a
{
buf[TCP_CHECKSUM_L_P+3+pos]=*s;
d32: 4d 93 st X+, r20
pos++;
d34: 2f 5f subi r18, 0xFF ; 255
d36: 3f 4f sbci r19, 0xFF ; 255
s++;
d38: 31 96 adiw r30, 0x01 ; 1
}
return(pos);
}
uint16_t fill_tcp_data(uint8_t *buf,uint16_t pos, const char *s)//функция записи строковых данных в буфер
{
while (*s)
d3a: 40 81 ld r20, Z
d3c: 44 23 and r20, r20
d3e: c9 f7 brne .-14 ; 0xd32
d40: a9 01 movw r20, r18
d42: 4a 5c subi r20, 0xCA ; 202
d44: 5f 4f sbci r21, 0xFF ; 255
plen=fill_tcp_data(buf,plen,baseurl);
plen=fill_tcp_data(buf,plen,password);
if (on_off)
d46: 66 23 and r22, r22
d48: 31 f4 brne .+12 ; 0xd56
d4a: dc 01 movw r26, r24
d4c: a4 0f add r26, r20
d4e: b5 1f adc r27, r21
{
plen=fill_tcp_data_p(buf,plen,PSTR("/0\">Выключить
"));
}
else
{
plen=fill_tcp_data_p(buf,plen,PSTR("/1\">Включить
"));
d50: 4a e8 ldi r20, 0x8A ; 138
d52: 51 e0 ldi r21, 0x01 ; 1
d54: 1c c0 rjmp .+56 ; 0xd8e
d56: dc 01 movw r26, r24
d58: a4 0f add r26, r20
d5a: b5 1f adc r27, r21
plen=fill_tcp_data_p(buf,plen,PSTR("\">[Проверить состояние]
\nВыключить
"));
d5c: 4e e9 ldi r20, 0x9E ; 158
d5e: 51 e0 ldi r21, 0x01 ; 1
d60: 03 c0 rjmp .+6 ; 0xd68
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
d62: 6d 93 st X+, r22
pos++;
d64: 2f 5f subi r18, 0xFF ; 255
d66: 3f 4f sbci r19, 0xFF ; 255
d68: fa 01 movw r30, r20
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
d6a: 4f 5f subi r20, 0xFF ; 255
d6c: 5f 4f sbci r21, 0xFF ; 255
d6e: 64 91 lpm r22, Z+
d70: 66 23 and r22, r22
d72: b9 f7 brne .-18 ; 0xd62
d74: 2a 5c subi r18, 0xCA ; 202
d76: 3f 4f sbci r19, 0xFF ; 255
d78: dc 01 movw r26, r24
d7a: a2 0f add r26, r18
d7c: b3 1f adc r27, r19
d7e: 26 53 subi r18, 0x36 ; 54
d80: 30 40 sbci r19, 0x00 ; 0
}
else
{
plen=fill_tcp_data_p(buf,plen,PSTR("/1\">Включить"));
}
plen=fill_tcp_data_p(buf,plen,PSTR("
Демонстрация работы платы "));
d82: 4e e5 ldi r20, 0x5E ; 94
d84: 51 e0 ldi r21, 0x01 ; 1
d86: 0d c0 rjmp .+26 ; 0xda2
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
d88: 6d 93 st X+, r22
pos++;
d8a: 2f 5f subi r18, 0xFF ; 255
d8c: 3f 4f sbci r19, 0xFF ; 255
d8e: fa 01 movw r30, r20
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
d90: 4f 5f subi r20, 0xFF ; 255
d92: 5f 4f sbci r21, 0xFF ; 255
d94: 64 91 lpm r22, Z+
d96: 66 23 and r22, r22
d98: b9 f7 brne .-18 ; 0xd88
d9a: ec cf rjmp .-40 ; 0xd74
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
d9c: 6d 93 st X+, r22
pos++;
d9e: 2f 5f subi r18, 0xFF ; 255
da0: 3f 4f sbci r19, 0xFF ; 255
da2: fa 01 movw r30, r20
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
da4: 4f 5f subi r20, 0xFF ; 255
da6: 5f 4f sbci r21, 0xFF ; 255
da8: 64 91 lpm r22, Z+
daa: 66 23 and r22, r22
dac: b9 f7 brne .-18 ; 0xd9c
dae: 2a 5c subi r18, 0xCA ; 202
db0: 3f 4f sbci r19, 0xFF ; 255
db2: dc 01 movw r26, r24
db4: a2 0f add r26, r18
db6: b3 1f adc r27, r19
db8: 26 53 subi r18, 0x36 ; 54
dba: 30 40 sbci r19, 0x00 ; 0
plen=fill_tcp_data_p(buf,plen,PSTR(" как Web-сервера. "));
dbc: 4b e4 ldi r20, 0x4B ; 75
dbe: 51 e0 ldi r21, 0x01 ; 1
dc0: 03 c0 rjmp .+6 ; 0xdc8
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
dc2: 6d 93 st X+, r22
pos++;
dc4: 2f 5f subi r18, 0xFF ; 255
dc6: 3f 4f sbci r19, 0xFF ; 255
dc8: fa 01 movw r30, r20
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
dca: 4f 5f subi r20, 0xFF ; 255
dcc: 5f 4f sbci r21, 0xFF ; 255
dce: 64 91 lpm r22, Z+
dd0: 66 23 and r22, r22
dd2: b9 f7 brne .-18 ; 0xdc2
dd4: 2a 5c subi r18, 0xCA ; 202
dd6: 3f 4f sbci r19, 0xFF ; 255
dd8: dc 01 movw r26, r24
dda: a2 0f add r26, r18
ddc: b3 1f adc r27, r19
dde: 26 53 subi r18, 0x36 ; 54
de0: 30 40 sbci r19, 0x00 ; 0
plen=fill_tcp_data_p(buf,plen,PSTR(" КубГУ.ФТФ. 2012 "));
de2: 89 e3 ldi r24, 0x39 ; 57
de4: 91 e0 ldi r25, 0x01 ; 1
de6: 03 c0 rjmp .+6 ; 0xdee
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
de8: 4d 93 st X+, r20
pos++;
dea: 2f 5f subi r18, 0xFF ; 255
dec: 3f 4f sbci r19, 0xFF ; 255
dee: fc 01 movw r30, r24
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
df0: 01 96 adiw r24, 0x01 ; 1
df2: 44 91 lpm r20, Z+
df4: 44 23 and r20, r20
df6: c1 f7 brne .-16 ; 0xde8
return(plen);
}
df8: c9 01 movw r24, r18
dfa: 08 95 ret
00000dfc :
static char baseurl[]="http://192.168.1.25/";//значение URL
#define BUFFER_SIZE 700// размер буфера для приема данных
static uint8_t buf[BUFFER_SIZE+1];
static char password[]="secret"; //пароль(не длиннее 9 символов)
uint8_t verify_password(char *str)//функция проверки пароля (первых 5 символов)
{
dfc: bc 01 movw r22, r24
if (strncmp(password,str,5)==0)
dfe: 87 e2 ldi r24, 0x27 ; 39
e00: 91 e0 ldi r25, 0x01 ; 1
e02: 45 e0 ldi r20, 0x05 ; 5
e04: 50 e0 ldi r21, 0x00 ; 0
e06: 0e 94 37 08 call 0x106e ; 0x106e
e0a: 9c 01 movw r18, r24
e0c: 80 e0 ldi r24, 0x00 ; 0
e0e: 23 2b or r18, r19
e10: 09 f4 brne .+2 ; 0xe14
e12: 81 e0 ldi r24, 0x01 ; 1
{
return(1);//при совпадении возвращает 1
}
return(0);//при не совпадении возвращает 0
}
e14: 08 95 ret
00000e16 :
int8_t analyse_get_url(char *str)// функция анализа получаемого URL
{
e16: cf 93 push r28
e18: df 93 push r29
e1a: ec 01 movw r28, r24
uint8_t i=0;
if (verify_password(str)==0)
e1c: 0e 94 fe 06 call 0xdfc ; 0xdfc
e20: 88 23 and r24, r24
e22: 11 f4 brne .+4 ; 0xe28
e24: 8f ef ldi r24, 0xFF ; 255
e26: 18 c0 rjmp .+48 ; 0xe58
e28: 30 e0 ldi r19, 0x00 ; 0
e2a: 08 c0 rjmp .+16 ; 0xe3c
e2c: ce 01 movw r24, r28
e2e: 01 96 adiw r24, 0x01 ; 1
{
return(-1);//возвращает -1, если пароль не правильный
}
while(*str && i<10 && *str >',' && *str<'{')//если пароль правильный, найдем положение символа '/'после пароля
{
if (*str=='/')
e30: 2f 32 cpi r18, 0x2F ; 47
e32: 11 f4 brne .+4 ; 0xe38
{
str++;
e34: ec 01 movw r28, r24
e36: 0b c0 rjmp .+22 ; 0xe4e
break;
}
i++;
e38: 3f 5f subi r19, 0xFF ; 255
str++;
e3a: ec 01 movw r28, r24
uint8_t i=0;
if (verify_password(str)==0)
{
return(-1);//возвращает -1, если пароль не правильный
}
while(*str && i<10 && *str >',' && *str<'{')//если пароль правильный, найдем положение символа '/'после пароля
e3c: 28 81 ld r18, Y
e3e: 22 23 and r18, r18
e40: 31 f0 breq .+12 ; 0xe4e
e42: 3a 30 cpi r19, 0x0A ; 10
e44: 21 f0 breq .+8 ; 0xe4e
e46: 2d 32 cpi r18, 0x2D ; 45
e48: 10 f0 brcs .+4 ; 0xe4e
e4a: 2b 37 cpi r18, 0x7B ; 123
e4c: 78 f3 brcs .-34 ; 0xe2c
break;
}
i++;
str++;
}
if (*str < 0x3a && *str > 0x2f)// если после '/' находится число от 0 до 9 (код ASCII)
e4e: 88 81 ld r24, Y
e50: 80 53 subi r24, 0x30 ; 48
e52: 8a 30 cpi r24, 0x0A ; 10
e54: 08 f0 brcs .+2 ; 0xe58
e56: 8e ef ldi r24, 0xFE ; 254
{
return(*str-0x30);//возвратим значение этого числа числа в прямом виде
}
return(-2);// если пароль верный, но нет команды после него, то возвращает -2
}
e58: df 91 pop r29
e5a: cf 91 pop r28
e5c: 08 95 ret
00000e5e :
plen=fill_tcp_data_p(buf,plen,PSTR(" КубГУ.ФТФ. 2012 "));
return(plen);
}
int main(void)
{
e5e: 0f 93 push r16
e60: 1f 93 push r17
e62: cf 93 push r28
e64: df 93 push r29
uint16_t plen;
uint16_t dat_p;
int8_t cmd;
PORTD=0x00;
e66: 1b b8 out 0x0b, r1 ; 11
DDRD=0xff;
e68: 8f ef ldi r24, 0xFF ; 255
e6a: 8a b9 out 0x0a, r24 ; 10
CLKPR=(1<
_delay_ms(10);
enc28j60Init(mymac);//инициализация ENC28J60
e7e: 88 e0 ldi r24, 0x08 ; 8
e80: 91 e0 ldi r25, 0x01 ; 1
e82: 0e 94 b6 03 call 0x76c ; 0x76c
e86: 00 e4 ldi r16, 0x40 ; 64
e88: 1c e9 ldi r17, 0x9C ; 156
e8a: c8 01 movw r24, r16
e8c: 01 97 sbiw r24, 0x01 ; 1
e8e: f1 f7 brne .-4 ; 0xe8c
_delay_ms(20);
enc28j60PhyWrite(PHLCON,0x476);//устанавливаем один диод для статуса соединения,другой для статуса приема/передачи
e90: 84 e1 ldi r24, 0x14 ; 20
e92: 66 e7 ldi r22, 0x76 ; 118
e94: 74 e0 ldi r23, 0x04 ; 4
e96: 0e 94 98 03 call 0x730 ; 0x730
e9a: c8 01 movw r24, r16
e9c: 01 97 sbiw r24, 0x01 ; 1
e9e: f1 f7 brne .-4 ; 0xe9c
_delay_ms(20);
init_ip_arp(mymac,myip);//инициализация ip- и MAC-адресов
ea0: 88 e0 ldi r24, 0x08 ; 8
ea2: 91 e0 ldi r25, 0x01 ; 1
ea4: 6e e0 ldi r22, 0x0E ; 14
ea6: 71 e0 ldi r23, 0x01 ; 1
ea8: 0e 94 e3 01 call 0x3c6 ; 0x3c6
while(1)
{
plen = enc28j60PacketReceive(BUFFER_SIZE, buf);//запускаем функцию приема пакетов от ENC28J60
eac: 8c eb ldi r24, 0xBC ; 188
eae: 92 e0 ldi r25, 0x02 ; 2
eb0: 61 e4 ldi r22, 0x41 ; 65
eb2: 71 e0 ldi r23, 0x01 ; 1
eb4: 0e 94 64 05 call 0xac8 ; 0xac8
eb8: ec 01 movw r28, r24
if(plen==0)// если принятых данных нет
eba: 00 97 sbiw r24, 0x00 ; 0
ebc: b9 f3 breq .-18 ; 0xeac
{
continue;//то перейти на начало цикла while
}
if(eth_type_is_arp_and_my_ip(buf,plen))// если полученные данные ARP-запрос,адресованный нам
ebe: 81 e4 ldi r24, 0x41 ; 65
ec0: 91 e0 ldi r25, 0x01 ; 1
ec2: be 01 movw r22, r28
ec4: 0e 94 03 02 call 0x406 ; 0x406
ec8: 88 23 and r24, r24
eca: 29 f0 breq .+10 ; 0xed6
{
make_arp_answer_from_request(buf);//то сгенерировать и отправить ARP-ответ
ecc: 81 e4 ldi r24, 0x41 ; 65
ece: 91 e0 ldi r25, 0x01 ; 1
ed0: 0e 94 3c 05 call 0xa78 ; 0xa78
ed4: eb cf rjmp .-42 ; 0xeac
continue;// перейти на начало цикла while
}
if(eth_type_is_ip_and_my_ip(buf,plen)==0)// если полученные данные являются ip-пакетом и адресованы не нам
ed6: 81 e4 ldi r24, 0x41 ; 65
ed8: 91 e0 ldi r25, 0x01 ; 1
eda: be 01 movw r22, r28
edc: 0e 94 1f 02 call 0x43e ; 0x43e
ee0: 88 23 and r24, r24
ee2: 21 f3 breq .-56 ; 0xeac
{
continue;// перейти на начало цикла while
}
if(buf[IP_PROTO_P]==IP_PROTO_ICMP_V && buf[ICMP_TYPE_P]==ICMP_TYPE_ECHOREQUEST_V)//если в полученном ip-пакете содержится запрос "пинг"
ee4: 80 91 58 01 lds r24, 0x0158
ee8: 81 30 cpi r24, 0x01 ; 1
eea: 51 f4 brne .+20 ; 0xf00
eec: 80 91 63 01 lds r24, 0x0163
ef0: 88 30 cpi r24, 0x08 ; 8
ef2: e1 f6 brne .-72 ; 0xeac
{
make_echo_reply_from_request(buf,plen);// отправим ответ "понг"
ef4: 81 e4 ldi r24, 0x41 ; 65
ef6: 91 e0 ldi r25, 0x01 ; 1
ef8: be 01 movw r22, r28
efa: 0e 94 1e 05 call 0xa3c ; 0xa3c
efe: d6 cf rjmp .-84 ; 0xeac
continue;//перейти на начало цикла while
}
if (buf[IP_PROTO_P]==IP_PROTO_TCP_V&&buf[TCP_DST_PORT_H_P]==0&&buf[TCP_DST_PORT_L_P]==80)// если полученные данные-TCP сегменты и адресованы нам (на порт 80)
f00: 86 30 cpi r24, 0x06 ; 6
f02: a1 f6 brne .-88 ; 0xeac
f04: 80 91 65 01 lds r24, 0x0165
f08: 88 23 and r24, r24
f0a: 81 f6 brne .-96 ; 0xeac
f0c: 80 91 66 01 lds r24, 0x0166
f10: 80 35 cpi r24, 0x50 ; 80
f12: 61 f6 brne .-104 ; 0xeac
{
if (buf[TCP_FLAGS_P] & TCP_FLAGS_SYN_V)//если идет запрос на синхронизацию
f14: 80 91 70 01 lds r24, 0x0170
f18: 81 ff sbrs r24, 1
f1a: 05 c0 rjmp .+10 ; 0xf26
{
make_tcp_synack_from_syn(buf);//отправим подтверждение синхронизации
f1c: 81 e4 ldi r24, 0x41 ; 65
f1e: 91 e0 ldi r25, 0x01 ; 1
f20: 0e 94 f6 04 call 0x9ec ; 0x9ec
f24: c3 cf rjmp .-122 ; 0xeac
continue;//выйдем из цикла и начнем принимать данные заново
}
if (buf[TCP_FLAGS_P] & TCP_FLAGS_ACK_V)//если установлен флаг подтверждения
f26: 84 ff sbrs r24, 4
f28: c1 cf rjmp .-126 ; 0xeac
{
init_len_info(buf); //определяем длину данных в TCP сегменте
f2a: 81 e4 ldi r24, 0x41 ; 65
f2c: 91 e0 ldi r25, 0x01 ; 1
f2e: 0e 94 c1 02 call 0x582 ; 0x582
buf[TCP_CHECKSUM_L_P]=ck& 0xff;
enc28j60PacketSend(IP_HEADER_LEN+TCP_HEADER_LEN_PLAIN+4+ETH_HEADER_LEN,buf);
}
uint16_t get_tcp_data_pointer(void)//функция расчета положения первого октета данных в буфере
{
if (info_data_len)
f32: 80 91 30 01 lds r24, 0x0130
f36: 90 91 31 01 lds r25, 0x0131
f3a: 89 2b or r24, r25
f3c: 41 f0 breq .+16 ; 0xf4e
{
return((uint16_t)TCP_SRC_PORT_H_P+info_hdr_len);
f3e: c0 91 32 01 lds r28, 0x0132
f42: d0 91 33 01 lds r29, 0x0133
f46: be 01 movw r22, r28
f48: 6e 5d subi r22, 0xDE ; 222
f4a: 7f 4f sbci r23, 0xFF ; 255
dat_p=get_tcp_data_pointer();//устанавливаем указатель на начало данных в TCP сегменте
if (dat_p==0)//прислан TCP сегмент без указания размера заголовка
f4c: 49 f4 brne .+18 ; 0xf60
{
if (buf[TCP_FLAGS_P] & TCP_FLAGS_FIN_V)//если флаг завершения соединения FIN установлен
f4e: 80 91 70 01 lds r24, 0x0170
f52: 80 ff sbrs r24, 0
f54: ab cf rjmp .-170 ; 0xeac
{
make_tcp_ack_from_any(buf);//подтвердить завершение
f56: 81 e4 ldi r24, 0x41 ; 65
f58: 91 e0 ldi r25, 0x01 ; 1
f5a: 0e 94 c8 04 call 0x990 ; 0x990
f5e: a6 cf rjmp .-180 ; 0xeac
}
continue;//и выйти из цикла
}
if (strncmp("GET ",(char *)&(buf[dat_p]),4)!=0)// если получен запрос "Get"
f60: 6f 5b subi r22, 0xBF ; 191
f62: 7e 4f sbci r23, 0xFE ; 254
f64: 80 e0 ldi r24, 0x00 ; 0
f66: 91 e0 ldi r25, 0x01 ; 1
f68: 44 e0 ldi r20, 0x04 ; 4
f6a: 50 e0 ldi r21, 0x00 ; 0
f6c: 0e 94 37 08 call 0x106e ; 0x106e
f70: 00 97 sbiw r24, 0x00 ; 0
f72: 79 f0 breq .+30 ; 0xf92
f74: c0 e0 ldi r28, 0x00 ; 0
f76: d0 e0 ldi r29, 0x00 ; 0
f78: 05 c0 rjmp .+10 ; 0xf84
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
f7a: fe 01 movw r30, r28
f7c: ef 5b subi r30, 0xBF ; 191
f7e: fe 4f sbci r31, 0xFE ; 254
f80: 86 ab std Z+54, r24 ; 0x36
pos++;
f82: 21 96 adiw r28, 0x01 ; 1
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
f84: fe 01 movw r30, r28
f86: e3 50 subi r30, 0x03 ; 3
f88: ff 4f sbci r31, 0xFF ; 255
f8a: 84 91 lpm r24, Z+
f8c: 88 23 and r24, r24
f8e: a9 f7 brne .-22 ; 0xf7a
f90: 64 c0 rjmp .+200 ; 0x105a
{
plen=fill_tcp_data_p(buf,0,PSTR("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n200 OK
"));//отправить команду 200 OK
goto SENDTCP;//перейти к отправке
}
if (strncmp("/ ",(char *)&(buf[dat_p+4]),2)==0)// если получен '/ '
f92: be 01 movw r22, r28
f94: 69 59 subi r22, 0x99 ; 153
f96: 7e 4f sbci r23, 0xFE ; 254
f98: 85 e0 ldi r24, 0x05 ; 5
f9a: 91 e0 ldi r25, 0x01 ; 1
f9c: 42 e0 ldi r20, 0x02 ; 2
f9e: 50 e0 ldi r21, 0x00 ; 0
fa0: 0e 94 37 08 call 0x106e ; 0x106e
fa4: 00 97 sbiw r24, 0x00 ; 0
fa6: a9 f5 brne .+106 ; 0x1012
fa8: c0 e0 ldi r28, 0x00 ; 0
faa: d0 e0 ldi r29, 0x00 ; 0
fac: 05 c0 rjmp .+10 ; 0xfb8
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
fae: fe 01 movw r30, r28
fb0: ef 5b subi r30, 0xBF ; 191
fb2: fe 4f sbci r31, 0xFE ; 254
fb4: 86 ab std Z+54, r24 ; 0x36
pos++;
fb6: 21 96 adiw r28, 0x01 ; 1
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
fb8: fe 01 movw r30, r28
fba: e0 53 subi r30, 0x30 ; 48
fbc: ff 4f sbci r31, 0xFF ; 255
fbe: 84 91 lpm r24, Z+
fc0: 88 23 and r24, r24
fc2: a9 f7 brne .-22 ; 0xfae
fc4: de 01 movw r26, r28
fc6: a9 58 subi r26, 0x89 ; 137
fc8: be 4f sbci r27, 0xFE ; 254
{
plen=fill_tcp_data_p(buf,0,PSTR("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n"));//отправить команду 200 OK
plen=fill_tcp_data_p(buf,plen,PSTR("Usage: "));// отправить подсказку ввести пароль: "Usage:http://192.168.1.25/password
fca: 85 ec ldi r24, 0xC5 ; 197
fcc: 90 e0 ldi r25, 0x00 ; 0
fce: 02 c0 rjmp .+4 ; 0xfd4
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
fd0: 2d 93 st X+, r18
pos++;
fd2: 21 96 adiw r28, 0x01 ; 1
fd4: fc 01 movw r30, r24
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
fd6: 01 96 adiw r24, 0x01 ; 1
fd8: 24 91 lpm r18, Z+
fda: 22 23 and r18, r18
fdc: c9 f7 brne .-14 ; 0xfd0
fde: de 01 movw r26, r28
fe0: a9 58 subi r26, 0x89 ; 137
fe2: be 4f sbci r27, 0xFE ; 254
fe4: e2 e1 ldi r30, 0x12 ; 18
fe6: f1 e0 ldi r31, 0x01 ; 1
fe8: 03 c0 rjmp .+6 ; 0xff0
}
uint16_t fill_tcp_data(uint8_t *buf,uint16_t pos, const char *s)//функция записи строковых данных в буфер
{
while (*s)
{
buf[TCP_CHECKSUM_L_P+3+pos]=*s;
fea: 8d 93 st X+, r24
pos++;
fec: 21 96 adiw r28, 0x01 ; 1
s++;
fee: 31 96 adiw r30, 0x01 ; 1
}
return(pos);
}
uint16_t fill_tcp_data(uint8_t *buf,uint16_t pos, const char *s)//функция записи строковых данных в буфер
{
while (*s)
ff0: 80 81 ld r24, Z
ff2: 88 23 and r24, r24
ff4: d1 f7 brne .-12 ; 0xfea
ff6: de 01 movw r26, r28
ff8: a9 58 subi r26, 0x89 ; 137
ffa: be 4f sbci r27, 0xFE ; 254
plen=fill_tcp_data(buf,plen,baseurl);
plen=fill_tcp_data_p(buf,plen,PSTR("password
"));
ffc: 88 eb ldi r24, 0xB8 ; 184
ffe: 90 e0 ldi r25, 0x00 ; 0
1000: 02 c0 rjmp .+4 ; 0x1006
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
1002: 2d 93 st X+, r18
pos++;
1004: 21 96 adiw r28, 0x01 ; 1
1006: fc 01 movw r30, r24
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
1008: 01 96 adiw r24, 0x01 ; 1
100a: 24 91 lpm r18, Z+
100c: 22 23 and r18, r18
100e: c9 f7 brne .-14 ; 0x1002
1010: 24 c0 rjmp .+72 ; 0x105a
goto SENDTCP;// перейти к отправке
}
cmd=analyse_get_url((char *)&(buf[dat_p+5]));//запускаем функцию анализа URL и записываем возвращаемое ею значение в cmd
1012: ce 01 movw r24, r28
1014: 88 59 subi r24, 0x98 ; 152
1016: 9e 4f sbci r25, 0xFE ; 254
1018: 0e 94 0b 07 call 0xe16 ; 0xe16
if (cmd==-1)// если пароль не верный
101c: 8f 3f cpi r24, 0xFF ; 255
101e: 79 f4 brne .+30 ; 0x103e
1020: c0 e0 ldi r28, 0x00 ; 0
1022: d0 e0 ldi r29, 0x00 ; 0
1024: 05 c0 rjmp .+10 ; 0x1030
{
buf[TCP_CHECKSUM_L_P+3+pos]=c;
1026: fe 01 movw r30, r28
1028: ef 5b subi r30, 0xBF ; 191
102a: fe 4f sbci r31, 0xFE ; 254
102c: 86 ab std Z+54, r24 ; 0x36
pos++;
102e: 21 96 adiw r28, 0x01 ; 1
}
}
uint16_t fill_tcp_data_p(uint8_t *buf,uint16_t pos, const prog_char *progmem_s)//функция записи строковых данных в буфер
{
char c;
while ((c = pgm_read_byte(progmem_s++)))
1030: fe 01 movw r30, r28
1032: e8 59 subi r30, 0x98 ; 152
1034: ff 4f sbci r31, 0xFF ; 255
1036: 84 91 lpm r24, Z+
1038: 88 23 and r24, r24
103a: a9 f7 brne .-22 ; 0x1026
103c: 0e c0 rjmp .+28 ; 0x105a
{
plen=fill_tcp_data_p(buf,0,PSTR("HTTP/1.0 401 Unauthorized\r\nContent-Type: text/html\r\n\r\n401 Unauthorized
"));//оправить команду отказано в авторизации
goto SENDTCP;//перейти к отправке
}
if (cmd==1)//если команда равна 1
103e: 81 30 cpi r24, 0x01 ; 1
1040: 11 f4 brne .+4 ; 0x1046
{
PORTD|= (1<
}
if (cmd==0)//если команда равна 0
1046: 88 23 and r24, r24
1048: 09 f4 brne .+2 ; 0x104c
{
PORTD &= ~(1<
1058: ec 01 movw r28, r24
SENDTCP:
make_tcp_ack_from_any(buf); // подтвердить запрос get
105a: 81 e4 ldi r24, 0x41 ; 65
105c: 91 e0 ldi r25, 0x01 ; 1
105e: 0e 94 c8 04 call 0x990 ; 0x990
make_tcp_ack_with_data(buf,plen); // отправить данные
1062: 81 e4 ldi r24, 0x41 ; 65
1064: 91 e0 ldi r25, 0x01 ; 1
1066: be 01 movw r22, r28
1068: 0e 94 9e 04 call 0x93c ; 0x93c
106c: 1f cf rjmp .-450 ; 0xeac
0000106e :
106e: fb 01 movw r30, r22
1070: dc 01 movw r26, r24
1072: 41 50 subi r20, 0x01 ; 1
1074: 50 40 sbci r21, 0x00 ; 0
1076: 30 f0 brcs .+12 ; 0x1084
1078: 8d 91 ld r24, X+
107a: 01 90 ld r0, Z+
107c: 80 19 sub r24, r0
107e: 19 f4 brne .+6 ; 0x1086
1080: 00 20 and r0, r0
1082: b9 f7 brne .-18 ; 0x1072
1084: 88 1b sub r24, r24
1086: 99 0b sbc r25, r25
1088: 08 95 ret
0000108a <_exit>:
108a: f8 94 cli
0000108c <__stop_program>:
108c: ff cf rjmp .-2 ; 0x108c <__stop_program>