9e: 0c 94 66 04 jmp 0x8cc ; 0x8cc <_exit> 000000a2 <__bad_interrupt>: a2: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> 000000a6 : void make_arp_answer_from_request(uint8_t *buf); void make_echo_reply_from_request(uint8_t *buf,uint16_t len); void make_udp_reply_from_request(uint8_t *buf,char *data,uint8_t datalen,uint16_t port); uint16_t checksum(uint8_t *buf, uint16_t len,uint8_t type) { a6: ef 92 push r14 a8: ff 92 push r15 aa: 0f 93 push r16 ac: 1f 93 push r17 ae: cf 93 push r28 b0: df 93 push r29 b2: 7c 01 movw r14, r24 uint32_t sum = 0; if(type==1){ b4: 41 30 cpi r20, 0x01 ; 1 b6: 29 f0 breq .+10 ; 0xc2 b8: 20 e0 ldi r18, 0x00 ; 0 ba: 30 e0 ldi r19, 0x00 ; 0 bc: 40 e0 ldi r20, 0x00 ; 0 be: 50 e0 ldi r21, 0x00 ; 0 c0: 0b c0 rjmp .+22 ; 0xd8 sum+=IP_PROTO_UDP_V; sum+=len-8; c2: 68 50 subi r22, 0x08 ; 8 c4: 70 40 sbci r23, 0x00 ; 0 c6: 9b 01 movw r18, r22 c8: 40 e0 ldi r20, 0x00 ; 0 ca: 50 e0 ldi r21, 0x00 ; 0 cc: 68 5f subi r22, 0xF8 ; 248 ce: 7f 4f sbci r23, 0xFF ; 255 d0: 2f 5e subi r18, 0xEF ; 239 d2: 3f 4f sbci r19, 0xFF ; 255 d4: 4f 4f sbci r20, 0xFF ; 255 d6: 5f 4f sbci r21, 0xFF ; 255 d8: e7 01 movw r28, r14 da: 8b 01 movw r16, r22 dc: 0f c0 rjmp .+30 ; 0xfc } // переведем сумму в 16-битные слова while(len >1) { sum += 0xFFFF & (*buf<<8|*(buf+1)); de: f8 81 ld r31, Y e0: e0 e0 ldi r30, 0x00 ; 0 e2: 89 81 ldd r24, Y+1 ; 0x01 e4: 90 e0 ldi r25, 0x00 ; 0 e6: 8e 2b or r24, r30 e8: 9f 2b or r25, r31 ea: a0 e0 ldi r26, 0x00 ; 0 ec: b0 e0 ldi r27, 0x00 ; 0 ee: 28 0f add r18, r24 f0: 39 1f adc r19, r25 f2: 4a 1f adc r20, r26 f4: 5b 1f adc r21, r27 buf+=2; f6: 22 96 adiw r28, 0x02 ; 2 len-=2; f8: 02 50 subi r16, 0x02 ; 2 fa: 10 40 sbci r17, 0x00 ; 0 sum+=IP_PROTO_UDP_V; sum+=len-8; } // переведем сумму в 16-битные слова while(len >1) fc: 02 30 cpi r16, 0x02 ; 2 fe: 11 05 cpc r17, r1 100: 70 f7 brcc .-36 ; 0xde 102: fb 01 movw r30, r22 104: ee 7f andi r30, 0xFE ; 254 106: ee 0d add r30, r14 108: ff 1d adc r31, r15 sum += 0xFFFF & (*buf<<8|*(buf+1)); buf+=2; len-=2; } // если остался байт слева,дополним его нулями if (len){ 10a: 60 ff sbrs r22, 0 10c: 0d c0 rjmp .+26 ; 0x128 sum += (0xFF & *buf)<<8; 10e: 90 81 ld r25, Z 110: 80 e0 ldi r24, 0x00 ; 0 112: aa 27 eor r26, r26 114: 97 fd sbrc r25, 7 116: a0 95 com r26 118: ba 2f mov r27, r26 11a: 02 c0 rjmp .+4 ; 0x120 } while (sum>>16){ sum = (sum & 0xFFFF)+(sum >> 16); 11c: 40 70 andi r20, 0x00 ; 0 11e: 50 70 andi r21, 0x00 ; 0 120: 28 0f add r18, r24 122: 39 1f adc r19, r25 124: 4a 1f adc r20, r26 126: 5b 1f adc r21, r27 // если остался байт слева,дополним его нулями if (len){ sum += (0xFF & *buf)<<8; } while (sum>>16){ 128: ca 01 movw r24, r20 12a: aa 27 eor r26, r26 12c: bb 27 eor r27, r27 12e: 00 97 sbiw r24, 0x00 ; 0 130: a1 05 cpc r26, r1 132: b1 05 cpc r27, r1 134: 99 f7 brne .-26 ; 0x11c 136: 20 95 com r18 138: 30 95 com r19 sum = (sum & 0xFFFF)+(sum >> 16); } return( (uint16_t) sum ^ 0xFFFF); } 13a: c9 01 movw r24, r18 13c: df 91 pop r29 13e: cf 91 pop r28 140: 1f 91 pop r17 142: 0f 91 pop r16 144: ff 90 pop r15 146: ef 90 pop r14 148: 08 95 ret 0000014a : void init_ip_arp(uint8_t *mymac,uint8_t *myip)// функция генерации ip- и MAC-адресов, которые будут переданы в пакет и фрейм соответственно { 14a: ac 01 movw r20, r24 14c: 20 e0 ldi r18, 0x00 ; 0 14e: 30 e0 ldi r19, 0x00 ; 0 uint8_t i=0; while(i<4) { ipaddr[i]=myip[i];// присваиваем ip-адресу, который впоследствии будет отправлен в ip- пакете значение нашего ip 150: f9 01 movw r30, r18 152: e8 5d subi r30, 0xD8 ; 216 154: fe 4f sbci r31, 0xFE ; 254 156: db 01 movw r26, r22 158: a2 0f add r26, r18 15a: b3 1f adc r27, r19 15c: 8c 91 ld r24, X 15e: 80 83 st Z, r24 160: 2f 5f subi r18, 0xFF ; 255 162: 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) 164: 24 30 cpi r18, 0x04 ; 4 166: 31 05 cpc r19, r1 168: 99 f7 brne .-26 ; 0x150 16a: 20 e0 ldi r18, 0x00 ; 0 16c: 30 e0 ldi r19, 0x00 ; 0 i++; } i=0; while(i<6) { macaddr[i]=mymac[i];// присваиваем MAC-адресу, который впоследствии будет отправлен в Ethernet-фрейме значение нашего MAC 16e: f9 01 movw r30, r18 170: ee 5d subi r30, 0xDE ; 222 172: fe 4f sbci r31, 0xFE ; 254 174: da 01 movw r26, r20 176: a2 0f add r26, r18 178: b3 1f adc r27, r19 17a: 8c 91 ld r24, X 17c: 80 83 st Z, r24 17e: 2f 5f subi r18, 0xFF ; 255 180: 3f 4f sbci r19, 0xFF ; 255 { ipaddr[i]=myip[i];// присваиваем ip-адресу, который впоследствии будет отправлен в ip- пакете значение нашего ip i++; } i=0; while(i<6) 182: 26 30 cpi r18, 0x06 ; 6 184: 31 05 cpc r19, r1 186: 99 f7 brne .-26 ; 0x16e { macaddr[i]=mymac[i];// присваиваем MAC-адресу, который впоследствии будет отправлен в Ethernet-фрейме значение нашего MAC i++; } } 188: 08 95 ret 0000018a : uint8_t eth_type_is_arp_and_my_ip(uint8_t *buf,uint16_t len)// функция проверки, является ли полученный пакет ARP-запросом и предназначен ли нам? { 18a: fc 01 movw r30, r24 uint8_t i=0; if (len<41) 18c: 69 32 cpi r22, 0x29 ; 41 18e: 71 05 cpc r23, r1 190: b0 f0 brcs .+44 ; 0x1be { return(0); } if(buf[ETH_TYPE_H_P] != ETHTYPE_ARP_H_V || buf[ETH_TYPE_L_P] != ETHTYPE_ARP_L_V) 192: 84 85 ldd r24, Z+12 ; 0x0c 194: 88 30 cpi r24, 0x08 ; 8 196: 99 f4 brne .+38 ; 0x1be 198: 85 85 ldd r24, Z+13 ; 0x0d 19a: 86 30 cpi r24, 0x06 ; 6 19c: 81 f4 brne .+32 ; 0x1be 19e: df 01 movw r26, r30 1a0: 96 96 adiw r26, 0x26 ; 38 1a2: e8 e2 ldi r30, 0x28 ; 40 1a4: f1 e0 ldi r31, 0x01 ; 1 { return(0); } while(i<4) { if(buf[ETH_ARP_DST_IP_P+i] != ipaddr[i]) 1a6: 9c 91 ld r25, X 1a8: 80 81 ld r24, Z 1aa: 98 17 cp r25, r24 1ac: 41 f4 brne .+16 ; 0x1be 1ae: 11 96 adiw r26, 0x01 ; 1 1b0: 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) 1b2: 81 e0 ldi r24, 0x01 ; 1 1b4: ec 32 cpi r30, 0x2C ; 44 1b6: f8 07 cpc r31, r24 1b8: b1 f7 brne .-20 ; 0x1a6 1ba: 81 e0 ldi r24, 0x01 ; 1 1bc: 08 95 ret 1be: 80 e0 ldi r24, 0x00 ; 0 return(0); } i++; } return(1);//в случае успеха возвращает значение 1 } 1c0: 08 95 ret 000001c2 : uint8_t eth_type_is_ip_and_my_ip(uint8_t *buf,uint16_t len)// функция проверки, адресован ли полученный IP пакет нам? { 1c2: fc 01 movw r30, r24 uint8_t i=0; if (len<42) 1c4: 6a 32 cpi r22, 0x2A ; 42 1c6: 71 05 cpc r23, r1 1c8: d0 f0 brcs .+52 ; 0x1fe { return(0); } if(buf[ETH_TYPE_H_P]!=ETHTYPE_IP_H_V || buf[ETH_TYPE_L_P]!=ETHTYPE_IP_L_V) 1ca: 84 85 ldd r24, Z+12 ; 0x0c 1cc: 88 30 cpi r24, 0x08 ; 8 1ce: b9 f4 brne .+46 ; 0x1fe 1d0: 85 85 ldd r24, Z+13 ; 0x0d 1d2: 88 23 and r24, r24 1d4: a1 f4 brne .+40 ; 0x1fe { return(0); } if (buf[IP_HEADER_LEN_VER_P]!=0x45) 1d6: 86 85 ldd r24, Z+14 ; 0x0e 1d8: 85 34 cpi r24, 0x45 ; 69 1da: 89 f4 brne .+34 ; 0x1fe 1dc: df 01 movw r26, r30 1de: e8 e2 ldi r30, 0x28 ; 40 1e0: f1 e0 ldi r31, 0x01 ; 1 { return(0); } while(i<4) { if(buf[IP_DST_P+i]!=ipaddr[i]) 1e2: 5e 96 adiw r26, 0x1e ; 30 1e4: 9c 91 ld r25, X 1e6: 5e 97 sbiw r26, 0x1e ; 30 1e8: 80 81 ld r24, Z 1ea: 98 17 cp r25, r24 1ec: 41 f4 brne .+16 ; 0x1fe 1ee: 11 96 adiw r26, 0x01 ; 1 1f0: 31 96 adiw r30, 0x01 ; 1 } if (buf[IP_HEADER_LEN_VER_P]!=0x45) { return(0); } while(i<4) 1f2: 81 e0 ldi r24, 0x01 ; 1 1f4: ec 32 cpi r30, 0x2C ; 44 1f6: f8 07 cpc r31, r24 1f8: a1 f7 brne .-24 ; 0x1e2 1fa: 81 e0 ldi r24, 0x01 ; 1 1fc: 08 95 ret 1fe: 80 e0 ldi r24, 0x00 ; 0 return(0); } i++; } return(1);//если да, то возвращает 1 } 200: 08 95 ret 00000202 : void make_eth(uint8_t *buf)//функция замены MAC-адреса источника на МАС-адрес получателя { 202: fc 01 movw r30, r24 204: a2 e2 ldi r26, 0x22 ; 34 206: b1 e0 ldi r27, 0x01 ; 1 uint8_t i=0; while(i<6) { buf[ETH_DST_MAC +i]=buf[ETH_SRC_MAC +i]; 208: 86 81 ldd r24, Z+6 ; 0x06 20a: 80 83 st Z, r24 buf[ETH_SRC_MAC +i]=macaddr[i]; 20c: 8d 91 ld r24, X+ 20e: 86 83 std Z+6, r24 ; 0x06 210: 31 96 adiw r30, 0x01 ; 1 } void make_eth(uint8_t *buf)//функция замены MAC-адреса источника на МАС-адрес получателя { uint8_t i=0; while(i<6) 212: 81 e0 ldi r24, 0x01 ; 1 214: a8 32 cpi r26, 0x28 ; 40 216: b8 07 cpc r27, r24 218: b9 f7 brne .-18 ; 0x208 { buf[ETH_DST_MAC +i]=buf[ETH_SRC_MAC +i]; buf[ETH_SRC_MAC +i]=macaddr[i]; i++; } } 21a: 08 95 ret 0000021c : void fill_ip_hdr_checksum(uint8_t *buf)// функция генерации контрольной суммы, флагов, времени жизни для отправляемого IP пакета { 21c: 0f 93 push r16 21e: 1f 93 push r17 220: 8c 01 movw r16, r24 uint16_t ck; buf[IP_CHECKSUM_P]=0; 222: fc 01 movw r30, r24 224: 10 8e std Z+24, r1 ; 0x18 buf[IP_CHECKSUM_P+1]=0; 226: 11 8e std Z+25, r1 ; 0x19 buf[IP_FLAGS_P]=0x40; 228: 80 e4 ldi r24, 0x40 ; 64 22a: 84 8b std Z+20, r24 ; 0x14 buf[IP_FLAGS_P+1]=0; 22c: 15 8a std Z+21, r1 ; 0x15 buf[IP_TTL_P]=64; 22e: 86 8b std Z+22, r24 ; 0x16 ck=checksum(&buf[IP_P], IP_HEADER_LEN,0); 230: c8 01 movw r24, r16 232: 0e 96 adiw r24, 0x0e ; 14 234: 64 e1 ldi r22, 0x14 ; 20 236: 70 e0 ldi r23, 0x00 ; 0 238: 40 e0 ldi r20, 0x00 ; 0 23a: 0e 94 53 00 call 0xa6 ; 0xa6 buf[IP_CHECKSUM_P]=ck>>8; 23e: f8 01 movw r30, r16 240: 90 8f std Z+24, r25 ; 0x18 buf[IP_CHECKSUM_P+1]=ck& 0xff; 242: 81 8f std Z+25, r24 ; 0x19 } 244: 1f 91 pop r17 246: 0f 91 pop r16 248: 08 95 ret 0000024a : void make_ip(uint8_t *buf)//функция генерации ip пакета для отправления { 24a: ac 01 movw r20, r24 24c: fc 01 movw r30, r24 24e: a8 e2 ldi r26, 0x28 ; 40 250: b1 e0 ldi r27, 0x01 ; 1 uint8_t i=0; while(i<4) { buf[IP_DST_P+i]=buf[IP_SRC_P+i]; 252: 82 8d ldd r24, Z+26 ; 0x1a 254: 86 8f std Z+30, r24 ; 0x1e buf[IP_SRC_P+i]=ipaddr[i]; 256: 8d 91 ld r24, X+ 258: 82 8f std Z+26, r24 ; 0x1a 25a: 31 96 adiw r30, 0x01 ; 1 } void make_ip(uint8_t *buf)//функция генерации ip пакета для отправления { uint8_t i=0; while(i<4) 25c: 81 e0 ldi r24, 0x01 ; 1 25e: ac 32 cpi r26, 0x2C ; 44 260: b8 07 cpc r27, r24 262: b9 f7 brne .-18 ; 0x252 { buf[IP_DST_P+i]=buf[IP_SRC_P+i]; buf[IP_SRC_P+i]=ipaddr[i]; i++; } fill_ip_hdr_checksum(buf); 264: ca 01 movw r24, r20 266: 0e 94 0e 01 call 0x21c ; 0x21c } 26a: 08 95 ret 0000026c : #define waitspi() while(!(SPSR&(1< // read data SPDR = 0x00; 27c: 1e bc out 0x2e, r1 ; 46 waitspi(); 27e: 0d b4 in r0, 0x2d ; 45 280: 07 fe sbrs r0, 7 282: fd cf rjmp .-6 ; 0x27e // do dummy read if needed (for mac and mii, see datasheet page 29) if(address & 0x80) 284: 67 ff sbrs r22, 7 286: 04 c0 rjmp .+8 ; 0x290 { SPDR = 0x00; 288: 1e bc out 0x2e, r1 ; 46 waitspi(); 28a: 0d b4 in r0, 0x2d ; 45 28c: 07 fe sbrs r0, 7 28e: fd cf rjmp .-6 ; 0x28a } // release CS CSPASSIVE; 290: 2a 9a sbi 0x05, 2 ; 5 return(SPDR); 292: 8e b5 in r24, 0x2e ; 46 } 294: 08 95 ret 00000296 : void enc28j60WriteOp(uint8_t op, uint8_t address, uint8_t data) { CSACTIVE; 296: 2a 98 cbi 0x05, 2 ; 5 // issue write command SPDR = op | (address & ADDR_MASK); 298: 6f 71 andi r22, 0x1F ; 31 29a: 68 2b or r22, r24 29c: 6e bd out 0x2e, r22 ; 46 waitspi(); 29e: 0d b4 in r0, 0x2d ; 45 2a0: 07 fe sbrs r0, 7 2a2: fd cf rjmp .-6 ; 0x29e // write data SPDR = data; 2a4: 4e bd out 0x2e, r20 ; 46 waitspi(); 2a6: 0d b4 in r0, 0x2d ; 45 2a8: 07 fe sbrs r0, 7 2aa: fd cf rjmp .-6 ; 0x2a6 CSPASSIVE; 2ac: 2a 9a sbi 0x05, 2 ; 5 } 2ae: 08 95 ret 000002b0 : void enc28j60ReadBuffer(uint16_t len, uint8_t* data) { 2b0: ac 01 movw r20, r24 2b2: fb 01 movw r30, r22 CSACTIVE; 2b4: 2a 98 cbi 0x05, 2 ; 5 // issue read command SPDR = ENC28J60_READ_BUF_MEM; 2b6: 8a e3 ldi r24, 0x3A ; 58 2b8: 8e bd out 0x2e, r24 ; 46 waitspi(); 2ba: 0d b4 in r0, 0x2d ; 45 2bc: 07 fe sbrs r0, 7 2be: fd cf rjmp .-6 ; 0x2ba 2c0: 9a 01 movw r18, r20 2c2: df 01 movw r26, r30 2c4: 08 c0 rjmp .+16 ; 0x2d6 while(len) { len--; // read data SPDR = 0x00; 2c6: 1e bc out 0x2e, r1 ; 46 waitspi(); 2c8: 0d b4 in r0, 0x2d ; 45 2ca: 07 fe sbrs r0, 7 2cc: fd cf rjmp .-6 ; 0x2c8 // issue read command SPDR = ENC28J60_READ_BUF_MEM; waitspi(); while(len) { len--; 2ce: 21 50 subi r18, 0x01 ; 1 2d0: 30 40 sbci r19, 0x00 ; 0 // read data SPDR = 0x00; waitspi(); *data = SPDR; 2d2: 8e b5 in r24, 0x2e ; 46 2d4: 8d 93 st X+, r24 { CSACTIVE; // issue read command SPDR = ENC28J60_READ_BUF_MEM; waitspi(); while(len) 2d6: 21 15 cp r18, r1 2d8: 31 05 cpc r19, r1 2da: a9 f7 brne .-22 ; 0x2c6 SPDR = 0x00; waitspi(); *data = SPDR; data++; } *data='\0'; 2dc: e4 0f add r30, r20 2de: f5 1f adc r31, r21 2e0: 10 82 st Z, r1 CSPASSIVE; 2e2: 2a 9a sbi 0x05, 2 ; 5 } 2e4: 08 95 ret 000002e6 : void enc28j60WriteBuffer(uint16_t len, uint8_t* data) { 2e6: 9c 01 movw r18, r24 2e8: fb 01 movw r30, r22 CSACTIVE; 2ea: 2a 98 cbi 0x05, 2 ; 5 // issue write command SPDR = ENC28J60_WRITE_BUF_MEM; 2ec: 8a e7 ldi r24, 0x7A ; 122 2ee: 8e bd out 0x2e, r24 ; 46 waitspi(); 2f0: 0d b4 in r0, 0x2d ; 45 2f2: 07 fe sbrs r0, 7 2f4: fd cf rjmp .-6 ; 0x2f0 2f6: 08 c0 rjmp .+16 ; 0x308 while(len) { len--; // write data SPDR = *data; 2f8: 80 81 ld r24, Z 2fa: 8e bd out 0x2e, r24 ; 46 data++; waitspi(); 2fc: 0d b4 in r0, 0x2d ; 45 2fe: 07 fe sbrs r0, 7 300: fd cf rjmp .-6 ; 0x2fc // issue write command SPDR = ENC28J60_WRITE_BUF_MEM; waitspi(); while(len) { len--; 302: 21 50 subi r18, 0x01 ; 1 304: 30 40 sbci r19, 0x00 ; 0 // write data SPDR = *data; data++; 306: 31 96 adiw r30, 0x01 ; 1 { CSACTIVE; // issue write command SPDR = ENC28J60_WRITE_BUF_MEM; waitspi(); while(len) 308: 21 15 cp r18, r1 30a: 31 05 cpc r19, r1 30c: a9 f7 brne .-22 ; 0x2f8 // write data SPDR = *data; data++; waitspi(); } CSPASSIVE; 30e: 2a 9a sbi 0x05, 2 ; 5 } 310: 08 95 ret 00000312 : void enc28j60SetBank(uint8_t address) { 312: 1f 93 push r17 314: cf 93 push r28 316: df 93 push r29 318: 18 2f mov r17, r24 // set the bank (if needed) if((address & BANK_MASK) != Enc28j60Bank) 31a: c8 2f mov r28, r24 31c: d0 e0 ldi r29, 0x00 ; 0 31e: c0 76 andi r28, 0x60 ; 96 320: d0 70 andi r29, 0x00 ; 0 322: 80 91 2c 01 lds r24, 0x012C 326: 90 e0 ldi r25, 0x00 ; 0 328: c8 17 cp r28, r24 32a: d9 07 cpc r29, r25 32c: 91 f0 breq .+36 ; 0x352 { // set the bank enc28j60WriteOp(ENC28J60_BIT_FIELD_CLR, ECON1, (ECON1_BSEL1|ECON1_BSEL0)); 32e: 80 ea ldi r24, 0xA0 ; 160 330: 6f e1 ldi r22, 0x1F ; 31 332: 43 e0 ldi r20, 0x03 ; 3 334: 0e 94 4b 01 call 0x296 ; 0x296 enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, (address & BANK_MASK)>>5); 338: 95 e0 ldi r25, 0x05 ; 5 33a: d5 95 asr r29 33c: c7 95 ror r28 33e: 9a 95 dec r25 340: e1 f7 brne .-8 ; 0x33a 342: 80 e8 ldi r24, 0x80 ; 128 344: 6f e1 ldi r22, 0x1F ; 31 346: 4c 2f mov r20, r28 348: 0e 94 4b 01 call 0x296 ; 0x296 Enc28j60Bank = (address & BANK_MASK); 34c: 10 76 andi r17, 0x60 ; 96 34e: 10 93 2c 01 sts 0x012C, r17 } } 352: df 91 pop r29 354: cf 91 pop r28 356: 1f 91 pop r17 358: 08 95 ret 0000035a : uint8_t enc28j60Read(uint8_t address) { 35a: 1f 93 push r17 35c: 18 2f mov r17, r24 // set the bank enc28j60SetBank(address); 35e: 0e 94 89 01 call 0x312 ; 0x312 // do the read return enc28j60ReadOp(ENC28J60_READ_CTRL_REG, address); 362: 80 e0 ldi r24, 0x00 ; 0 364: 61 2f mov r22, r17 366: 0e 94 36 01 call 0x26c ; 0x26c } 36a: 1f 91 pop r17 36c: 08 95 ret 0000036e : void enc28j60Write(uint8_t address, uint8_t data) { 36e: 0f 93 push r16 370: 1f 93 push r17 372: 18 2f mov r17, r24 374: 06 2f mov r16, r22 // set the bank enc28j60SetBank(address); 376: 0e 94 89 01 call 0x312 ; 0x312 // do the write enc28j60WriteOp(ENC28J60_WRITE_CTRL_REG, address, data); 37a: 80 e4 ldi r24, 0x40 ; 64 37c: 61 2f mov r22, r17 37e: 40 2f mov r20, r16 380: 0e 94 4b 01 call 0x296 ; 0x296 } 384: 1f 91 pop r17 386: 0f 91 pop r16 388: 08 95 ret 0000038a : void enc28j60PhyWrite(uint8_t address, uint16_t data) { 38a: 0f 93 push r16 38c: 1f 93 push r17 38e: 98 2f mov r25, r24 390: 16 2f mov r17, r22 392: 07 2f mov r16, r23 // set the PHY register address enc28j60Write(MIREGADR, address); 394: 84 ed ldi r24, 0xD4 ; 212 396: 69 2f mov r22, r25 398: 0e 94 b7 01 call 0x36e ; 0x36e // write the PHY data enc28j60Write(MIWRL, data); 39c: 86 ed ldi r24, 0xD6 ; 214 39e: 61 2f mov r22, r17 3a0: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(MIWRH, data>>8); 3a4: 87 ed ldi r24, 0xD7 ; 215 3a6: 60 2f mov r22, r16 3a8: 0e 94 b7 01 call 0x36e ; 0x36e can be achieved. */ void _delay_loop_1(uint8_t __count) { __asm__ volatile ( 3ac: 18 e2 ldi r17, 0x28 ; 40 3ae: 03 c0 rjmp .+6 ; 0x3b6 3b0: 81 2f mov r24, r17 3b2: 8a 95 dec r24 3b4: f1 f7 brne .-4 ; 0x3b2 // wait until the PHY write completes while(enc28j60Read(MISTAT) & MISTAT_BUSY){ 3b6: 8a ee ldi r24, 0xEA ; 234 3b8: 0e 94 ad 01 call 0x35a ; 0x35a 3bc: 80 fd sbrc r24, 0 3be: f8 cf rjmp .-16 ; 0x3b0 _delay_us(15); } } 3c0: 1f 91 pop r17 3c2: 0f 91 pop r16 3c4: 08 95 ret 000003c6 : void enc28j60Init(uint8_t* macaddr) { 3c6: cf 93 push r28 3c8: df 93 push r29 3ca: ec 01 movw r28, r24 // initialize I/O ENC28J60_CONTROL_DDR |= 1< 3f2: 84 ef ldi r24, 0xF4 ; 244 3f4: 91 e0 ldi r25, 0x01 ; 1 milliseconds can be achieved. */ void _delay_loop_2(uint16_t __count) { __asm__ volatile ( 3f6: 28 ec ldi r18, 0xC8 ; 200 3f8: 30 e0 ldi r19, 0x00 ; 0 3fa: f9 01 movw r30, r18 3fc: 31 97 sbiw r30, 0x01 ; 1 3fe: f1 f7 brne .-4 ; 0x3fc __ticks = (uint16_t) (__ms * 10.0); while(__ticks) { // wait 1/10 ms _delay_loop_2(((F_CPU) / 4e3) / 10); __ticks --; 400: 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) 402: d9 f7 brne .-10 ; 0x3fa //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; 404: 10 92 2e 01 sts 0x012E, r1 408: 10 92 2d 01 sts 0x012D, r1 // Rx start enc28j60Write(ERXSTL, RXSTART_INIT&0xFF); 40c: 88 e0 ldi r24, 0x08 ; 8 40e: 60 e0 ldi r22, 0x00 ; 0 410: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(ERXSTH, RXSTART_INIT>>8); 414: 89 e0 ldi r24, 0x09 ; 9 416: 60 e0 ldi r22, 0x00 ; 0 418: 0e 94 b7 01 call 0x36e ; 0x36e // set receive pointer address enc28j60Write(ERXRDPTL, RXSTART_INIT&0xFF); 41c: 8c e0 ldi r24, 0x0C ; 12 41e: 60 e0 ldi r22, 0x00 ; 0 420: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(ERXRDPTH, RXSTART_INIT>>8); 424: 8d e0 ldi r24, 0x0D ; 13 426: 60 e0 ldi r22, 0x00 ; 0 428: 0e 94 b7 01 call 0x36e ; 0x36e // RX end enc28j60Write(ERXNDL, RXSTOP_INIT&0xFF); 42c: 8a e0 ldi r24, 0x0A ; 10 42e: 6e ef ldi r22, 0xFE ; 254 430: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(ERXNDH, RXSTOP_INIT>>8); 434: 8b e0 ldi r24, 0x0B ; 11 436: 69 e1 ldi r22, 0x19 ; 25 438: 0e 94 b7 01 call 0x36e ; 0x36e // TX start enc28j60Write(ETXSTL, TXSTART_INIT&0xFF); 43c: 84 e0 ldi r24, 0x04 ; 4 43e: 6f ef ldi r22, 0xFF ; 255 440: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(ETXSTH, TXSTART_INIT>>8); 444: 85 e0 ldi r24, 0x05 ; 5 446: 69 e1 ldi r22, 0x19 ; 25 448: 0e 94 b7 01 call 0x36e ; 0x36e // TX end enc28j60Write(ETXNDL, TXSTOP_INIT&0xFF); 44c: 86 e0 ldi r24, 0x06 ; 6 44e: 6f ef ldi r22, 0xFF ; 255 450: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(ETXNDH, TXSTOP_INIT>>8); 454: 87 e0 ldi r24, 0x07 ; 7 456: 6f e1 ldi r22, 0x1F ; 31 458: 0e 94 b7 01 call 0x36e ; 0x36e // 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); 45c: 88 e3 ldi r24, 0x38 ; 56 45e: 60 eb ldi r22, 0xB0 ; 176 460: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(EPMM0, 0x3f); 464: 88 e2 ldi r24, 0x28 ; 40 466: 6f e3 ldi r22, 0x3F ; 63 468: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(EPMM1, 0x30); 46c: 89 e2 ldi r24, 0x29 ; 41 46e: 60 e3 ldi r22, 0x30 ; 48 470: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(EPMCSL, 0xf9); 474: 80 e3 ldi r24, 0x30 ; 48 476: 69 ef ldi r22, 0xF9 ; 249 478: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(EPMCSH, 0xf7); 47c: 81 e3 ldi r24, 0x31 ; 49 47e: 67 ef ldi r22, 0xF7 ; 247 480: 0e 94 b7 01 call 0x36e ; 0x36e // // // do bank 2 stuff // enable MAC receive enc28j60Write(MACON1, MACON1_MARXEN|MACON1_TXPAUS|MACON1_RXPAUS); 484: 80 ec ldi r24, 0xC0 ; 192 486: 6d e0 ldi r22, 0x0D ; 13 488: 0e 94 b7 01 call 0x36e ; 0x36e // bring MAC out of reset enc28j60Write(MACON2, 0x00); 48c: 81 ec ldi r24, 0xC1 ; 193 48e: 60 e0 ldi r22, 0x00 ; 0 490: 0e 94 b7 01 call 0x36e ; 0x36e // enable automatic padding to 60bytes and CRC operations enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, MACON3, MACON3_PADCFG0|MACON3_TXCRCEN|MACON3_FRMLNEN); 494: 80 e8 ldi r24, 0x80 ; 128 496: 62 ec ldi r22, 0xC2 ; 194 498: 42 e3 ldi r20, 0x32 ; 50 49a: 0e 94 4b 01 call 0x296 ; 0x296 // set inter-frame gap (non-back-to-back) enc28j60Write(MAIPGL, 0x12); 49e: 86 ec ldi r24, 0xC6 ; 198 4a0: 62 e1 ldi r22, 0x12 ; 18 4a2: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(MAIPGH, 0x0C); 4a6: 87 ec ldi r24, 0xC7 ; 199 4a8: 6c e0 ldi r22, 0x0C ; 12 4aa: 0e 94 b7 01 call 0x36e ; 0x36e // set inter-frame gap (back-to-back) enc28j60Write(MABBIPG, 0x12); 4ae: 84 ec ldi r24, 0xC4 ; 196 4b0: 62 e1 ldi r22, 0x12 ; 18 4b2: 0e 94 b7 01 call 0x36e ; 0x36e // Set the maximum packet size which the controller will accept // Do not send packets longer than MAX_FRAMELEN: enc28j60Write(MAMXFLL, MAX_FRAMELEN&0xFF); 4b6: 8a ec ldi r24, 0xCA ; 202 4b8: 68 e5 ldi r22, 0x58 ; 88 4ba: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(MAMXFLH, MAX_FRAMELEN>>8); 4be: 8b ec ldi r24, 0xCB ; 203 4c0: 62 e0 ldi r22, 0x02 ; 2 4c2: 0e 94 b7 01 call 0x36e ; 0x36e // do bank 3 stuff // write MAC address // NOTE: MAC address in ENC28J60 is byte-backward enc28j60Write(MAADR5, macaddr[0]); 4c6: 84 ee ldi r24, 0xE4 ; 228 4c8: 68 81 ld r22, Y 4ca: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(MAADR4, macaddr[1]); 4ce: 85 ee ldi r24, 0xE5 ; 229 4d0: 69 81 ldd r22, Y+1 ; 0x01 4d2: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(MAADR3, macaddr[2]); 4d6: 82 ee ldi r24, 0xE2 ; 226 4d8: 6a 81 ldd r22, Y+2 ; 0x02 4da: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(MAADR2, macaddr[3]); 4de: 83 ee ldi r24, 0xE3 ; 227 4e0: 6b 81 ldd r22, Y+3 ; 0x03 4e2: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(MAADR1, macaddr[4]); 4e6: 80 ee ldi r24, 0xE0 ; 224 4e8: 6c 81 ldd r22, Y+4 ; 0x04 4ea: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(MAADR0, macaddr[5]); 4ee: 81 ee ldi r24, 0xE1 ; 225 4f0: 6d 81 ldd r22, Y+5 ; 0x05 4f2: 0e 94 b7 01 call 0x36e ; 0x36e // no loopback of transmitted frames enc28j60PhyWrite(PHCON2, PHCON2_HDLDIS); 4f6: 80 e1 ldi r24, 0x10 ; 16 4f8: 60 e0 ldi r22, 0x00 ; 0 4fa: 71 e0 ldi r23, 0x01 ; 1 4fc: 0e 94 c5 01 call 0x38a ; 0x38a // switch to bank 0 enc28j60SetBank(ECON1); 500: 8f e1 ldi r24, 0x1F ; 31 502: 0e 94 89 01 call 0x312 ; 0x312 // enable interrutps enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, EIE, EIE_INTIE|EIE_PKTIE); 506: 80 e8 ldi r24, 0x80 ; 128 508: 6b e1 ldi r22, 0x1B ; 27 50a: 40 ec ldi r20, 0xC0 ; 192 50c: 0e 94 4b 01 call 0x296 ; 0x296 // enable packet reception enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_RXEN); 510: 80 e8 ldi r24, 0x80 ; 128 512: 6f e1 ldi r22, 0x1F ; 31 514: 44 e0 ldi r20, 0x04 ; 4 516: 0e 94 4b 01 call 0x296 ; 0x296 } 51a: df 91 pop r29 51c: cf 91 pop r28 51e: 08 95 ret 00000520 : // read the revision of the chip: uint8_t enc28j60getrev(void) { return(enc28j60Read(EREVID)); 520: 82 e7 ldi r24, 0x72 ; 114 522: 0e 94 ad 01 call 0x35a ; 0x35a } 526: 08 95 ret 00000528 : void enc28j60PacketSend(uint16_t len, uint8_t* packet) { 528: ef 92 push r14 52a: ff 92 push r15 52c: 0f 93 push r16 52e: 1f 93 push r17 530: 8c 01 movw r16, r24 532: 7b 01 movw r14, r22 // Set the write pointer to start of transmit buffer area enc28j60Write(EWRPTL, TXSTART_INIT&0xFF); 534: 82 e0 ldi r24, 0x02 ; 2 536: 6f ef ldi r22, 0xFF ; 255 538: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(EWRPTH, TXSTART_INIT>>8); 53c: 83 e0 ldi r24, 0x03 ; 3 53e: 69 e1 ldi r22, 0x19 ; 25 540: 0e 94 b7 01 call 0x36e ; 0x36e // Set the TXND pointer to correspond to the packet size given enc28j60Write(ETXNDL, (TXSTART_INIT+len)&0xFF); 544: 60 2f mov r22, r16 546: 61 50 subi r22, 0x01 ; 1 548: 86 e0 ldi r24, 0x06 ; 6 54a: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(ETXNDH, (TXSTART_INIT+len)>>8); 54e: 98 01 movw r18, r16 550: 21 50 subi r18, 0x01 ; 1 552: 36 4e sbci r19, 0xE6 ; 230 554: 87 e0 ldi r24, 0x07 ; 7 556: 63 2f mov r22, r19 558: 0e 94 b7 01 call 0x36e ; 0x36e // write per-packet control byte (0x00 means use macon3 settings) enc28j60WriteOp(ENC28J60_WRITE_BUF_MEM, 0, 0x00); 55c: 8a e7 ldi r24, 0x7A ; 122 55e: 60 e0 ldi r22, 0x00 ; 0 560: 40 e0 ldi r20, 0x00 ; 0 562: 0e 94 4b 01 call 0x296 ; 0x296 // copy the packet into the transmit buffer enc28j60WriteBuffer(len, packet); 566: c8 01 movw r24, r16 568: b7 01 movw r22, r14 56a: 0e 94 73 01 call 0x2e6 ; 0x2e6 // send the contents of the transmit buffer onto the network enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_TXRTS); 56e: 80 e8 ldi r24, 0x80 ; 128 570: 6f e1 ldi r22, 0x1F ; 31 572: 48 e0 ldi r20, 0x08 ; 8 574: 0e 94 4b 01 call 0x296 ; 0x296 // Reset the transmit logic problem. See Rev. B4 Silicon Errata point 12. if( (enc28j60Read(EIR) & EIR_TXERIF) ){ 578: 8c e1 ldi r24, 0x1C ; 28 57a: 0e 94 ad 01 call 0x35a ; 0x35a 57e: 81 ff sbrs r24, 1 580: 05 c0 rjmp .+10 ; 0x58c enc28j60WriteOp(ENC28J60_BIT_FIELD_CLR, ECON1, ECON1_TXRTS); 582: 80 ea ldi r24, 0xA0 ; 160 584: 6f e1 ldi r22, 0x1F ; 31 586: 48 e0 ldi r20, 0x08 ; 8 588: 0e 94 4b 01 call 0x296 ; 0x296 } } 58c: 1f 91 pop r17 58e: 0f 91 pop r16 590: ff 90 pop r15 592: ef 90 pop r14 594: 08 95 ret 00000596 : buf[ICMP_CHECKSUM_P]+=0x08; enc28j60PacketSend(len,buf); } void make_udp_reply_from_request(uint8_t *buf,char *data,uint8_t datalen,uint16_t port)//функция ответа на UDP-запрос { 596: cf 92 push r12 598: df 92 push r13 59a: ff 92 push r15 59c: 0f 93 push r16 59e: 1f 93 push r17 5a0: cf 93 push r28 5a2: df 93 push r29 5a4: ec 01 movw r28, r24 5a6: 6b 01 movw r12, r22 5a8: 14 2f mov r17, r20 5aa: f2 2e mov r15, r18 5ac: 03 2f mov r16, r19 uint8_t i=0;//объявляем переменную i и приравниваем ее к нулю uint16_t ck;//объявляем переменную ck make_eth(buf);// заполним ethernet-заголовок 5ae: 0e 94 01 01 call 0x202 ; 0x202 5b2: 1d 3d cpi r17, 0xDD ; 221 5b4: 08 f0 brcs .+2 ; 0x5b8 5b6: 1c ed ldi r17, 0xDC ; 220 if (datalen>220)//определим максимальный размер данных для ответа (220 байт) { datalen=220; } buf[IP_TOTLEN_H_P]=0;//обнуляем старший байт поля "общая длина" заголовка IP 5b8: 18 8a std Y+16, r1 ; 0x10 buf[IP_TOTLEN_L_P]=IP_HEADER_LEN+UDP_HEADER_LEN+datalen;//устанавливаем младший байт поля "общая длина" заголовка IP 5ba: 14 5e subi r17, 0xE4 ; 228 5bc: 19 8b std Y+17, r17 ; 0x11 make_ip(buf);//заполним ip-заголовок 5be: ce 01 movw r24, r28 5c0: 0e 94 25 01 call 0x24a ; 0x24a buf[UDP_DST_PORT_H_P]=port>>8;//установим старший байт поля "порт назначения" заголовка UDP 5c4: 0c a3 std Y+36, r16 ; 0x24 buf[UDP_DST_PORT_L_P]=port & 0xff;//установим младший байт поля "порт назначения" заголовка UDP 5c6: fd a2 std Y+37, r15 ; 0x25 buf[UDP_LEN_H_P]=0;//обнуляем старший байт поля "длина дейтаграммы" заголовка UDP 5c8: 1e a2 std Y+38, r1 ; 0x26 buf[UDP_LEN_L_P]=UDP_HEADER_LEN+datalen;//устанавливаем младший байт поля "длина дейтаграммы" заголовка UDP 5ca: 14 51 subi r17, 0x14 ; 20 5cc: 1f a3 std Y+39, r17 ; 0x27 5ce: 18 50 subi r17, 0x08 ; 8 buf[UDP_CHECKSUM_H_P]=0;//обнуляем поле "контрольная сумма" заголовка UDP 5d0: 18 a6 std Y+40, r1 ; 0x28 buf[UDP_CHECKSUM_L_P]=0; 5d2: 19 a6 std Y+41, r1 ; 0x29 5d4: de 01 movw r26, r28 5d6: 9a 96 adiw r26, 0x2a ; 42 5d8: 20 e0 ldi r18, 0x00 ; 0 5da: 30 e0 ldi r19, 0x00 ; 0 5dc: 07 c0 rjmp .+14 ; 0x5ec while(i { buf[UDP_DATA_P+i]=data[i]; i++; } ck=checksum(&buf[IP_SRC_P], 16 + datalen,1);//вычисляем контрольную сумму для UDP-заголовка 5f0: 01 2f mov r16, r17 5f2: 10 e0 ldi r17, 0x00 ; 0 5f4: 00 5f subi r16, 0xF0 ; 240 5f6: 1f 4f sbci r17, 0xFF ; 255 5f8: ce 01 movw r24, r28 5fa: 4a 96 adiw r24, 0x1a ; 26 5fc: b8 01 movw r22, r16 5fe: 41 e0 ldi r20, 0x01 ; 1 600: 0e 94 53 00 call 0xa6 ; 0xa6 buf[UDP_CHECKSUM_H_P]=ck>>8;//записываем вычисленную контрольную сумму в буфер 604: 98 a7 std Y+40, r25 ; 0x28 buf[UDP_CHECKSUM_L_P]=ck& 0xff; 606: 89 a7 std Y+41, r24 ; 0x29 enc28j60PacketSend(UDP_HEADER_LEN+IP_HEADER_LEN+ETH_HEADER_LEN+datalen,buf);//отправляем ответ UDP 608: c8 01 movw r24, r16 60a: 4a 96 adiw r24, 0x1a ; 26 60c: be 01 movw r22, r28 60e: 0e 94 94 02 call 0x528 ; 0x528 } 612: df 91 pop r29 614: cf 91 pop r28 616: 1f 91 pop r17 618: 0f 91 pop r16 61a: ff 90 pop r15 61c: df 90 pop r13 61e: cf 90 pop r12 620: 08 95 ret 00000622 : } enc28j60PacketSend(42,buf); } void make_echo_reply_from_request(uint8_t *buf,uint16_t len)// функция генерации понг-ответа для отправления { 622: 0f 93 push r16 624: 1f 93 push r17 626: cf 93 push r28 628: df 93 push r29 62a: ec 01 movw r28, r24 62c: 8b 01 movw r16, r22 make_eth(buf); 62e: 0e 94 01 01 call 0x202 ; 0x202 make_ip(buf); 632: ce 01 movw r24, r28 634: 0e 94 25 01 call 0x24a ; 0x24a buf[ICMP_TYPE_P]=ICMP_TYPE_ECHOREPLY_V; 638: 1a a2 std Y+34, r1 ; 0x22 if (buf[ICMP_CHECKSUM_P] > (0xff-0x08)) 63a: 8c a1 ldd r24, Y+36 ; 0x24 63c: 88 3f cpi r24, 0xF8 ; 248 63e: 18 f0 brcs .+6 ; 0x646 { buf[ICMP_CHECKSUM_P+1]++; 640: 8d a1 ldd r24, Y+37 ; 0x25 642: 8f 5f subi r24, 0xFF ; 255 644: 8d a3 std Y+37, r24 ; 0x25 } buf[ICMP_CHECKSUM_P]+=0x08; 646: 8c a1 ldd r24, Y+36 ; 0x24 648: 88 5f subi r24, 0xF8 ; 248 64a: 8c a3 std Y+36, r24 ; 0x24 enc28j60PacketSend(len,buf); 64c: c8 01 movw r24, r16 64e: be 01 movw r22, r28 650: 0e 94 94 02 call 0x528 ; 0x528 } 654: df 91 pop r29 656: cf 91 pop r28 658: 1f 91 pop r17 65a: 0f 91 pop r16 65c: 08 95 ret 0000065e : } fill_ip_hdr_checksum(buf); } void make_arp_answer_from_request(uint8_t *buf)// функция генерации ARP-ответа для отправления { 65e: cf 93 push r28 660: df 93 push r29 662: ec 01 movw r28, r24 uint8_t i=0; make_eth(buf); 664: 0e 94 01 01 call 0x202 ; 0x202 buf[ETH_ARP_OPCODE_H_P]=ETH_ARP_OPCODE_REPLY_H_V; 668: 1c 8a std Y+20, r1 ; 0x14 buf[ETH_ARP_OPCODE_L_P]=ETH_ARP_OPCODE_REPLY_L_V; 66a: 82 e0 ldi r24, 0x02 ; 2 66c: 8d 8b std Y+21, r24 ; 0x15 66e: fe 01 movw r30, r28 670: a2 e2 ldi r26, 0x22 ; 34 672: b1 e0 ldi r27, 0x01 ; 1 while(i<6) { buf[ETH_ARP_DST_MAC_P+i]=buf[ETH_ARP_SRC_MAC_P+i]; 674: 86 89 ldd r24, Z+22 ; 0x16 676: 80 a3 std Z+32, r24 ; 0x20 buf[ETH_ARP_SRC_MAC_P+i]=macaddr[i]; 678: 8d 91 ld r24, X+ 67a: 86 8b std Z+22, r24 ; 0x16 67c: 31 96 adiw r30, 0x01 ; 1 { uint8_t i=0; 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) 67e: 81 e0 ldi r24, 0x01 ; 1 680: a8 32 cpi r26, 0x28 ; 40 682: b8 07 cpc r27, r24 684: b9 f7 brne .-18 ; 0x674 686: fe 01 movw r30, r28 688: 7c 96 adiw r30, 0x1c ; 28 68a: a8 e2 ldi r26, 0x28 ; 40 68c: b1 e0 ldi r27, 0x01 ; 1 i++; } i=0; while(i<4) { buf[ETH_ARP_DST_IP_P+i]=buf[ETH_ARP_SRC_IP_P+i]; 68e: 80 81 ld r24, Z 690: 82 87 std Z+10, r24 ; 0x0a buf[ETH_ARP_SRC_IP_P+i]=ipaddr[i]; 692: 8d 91 ld r24, X+ 694: 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) 696: 81 e0 ldi r24, 0x01 ; 1 698: ac 32 cpi r26, 0x2C ; 44 69a: b8 07 cpc r27, r24 69c: c1 f7 brne .-16 ; 0x68e { 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); 69e: 8a e2 ldi r24, 0x2A ; 42 6a0: 90 e0 ldi r25, 0x00 ; 0 6a2: be 01 movw r22, r28 6a4: 0e 94 94 02 call 0x528 ; 0x528 } 6a8: df 91 pop r29 6aa: cf 91 pop r28 6ac: 08 95 ret 000006ae : // 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) { 6ae: af 92 push r10 6b0: bf 92 push r11 6b2: cf 92 push r12 6b4: df 92 push r13 6b6: ef 92 push r14 6b8: ff 92 push r15 6ba: 0f 93 push r16 6bc: 1f 93 push r17 6be: cf 93 push r28 6c0: df 93 push r29 6c2: 6c 01 movw r12, r24 6c4: 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 ){ 6c6: 89 e3 ldi r24, 0x39 ; 57 6c8: 0e 94 ad 01 call 0x35a ; 0x35a 6cc: 88 23 and r24, r24 6ce: 19 f4 brne .+6 ; 0x6d6 6d0: 00 e0 ldi r16, 0x00 ; 0 6d2: 10 e0 ldi r17, 0x00 ; 0 6d4: 5a c0 rjmp .+180 ; 0x78a return(0); } // Set the read pointer to the start of the received packet enc28j60Write(ERDPTL, (NextPacketPtr)); 6d6: 60 91 2d 01 lds r22, 0x012D 6da: 10 91 2e 01 lds r17, 0x012E 6de: 80 e0 ldi r24, 0x00 ; 0 6e0: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(ERDPTH, (NextPacketPtr)>>8); 6e4: 81 e0 ldi r24, 0x01 ; 1 6e6: 61 2f mov r22, r17 6e8: 0e 94 b7 01 call 0x36e ; 0x36e // read the next packet pointer NextPacketPtr = enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0); 6ec: 8a e3 ldi r24, 0x3A ; 58 6ee: 60 e0 ldi r22, 0x00 ; 0 6f0: 0e 94 36 01 call 0x26c ; 0x26c 6f4: 18 2f mov r17, r24 NextPacketPtr |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8; 6f6: 8a e3 ldi r24, 0x3A ; 58 6f8: 60 e0 ldi r22, 0x00 ; 0 6fa: 0e 94 36 01 call 0x26c ; 0x26c 6fe: 38 2f mov r19, r24 700: 20 e0 ldi r18, 0x00 ; 0 702: c1 2f mov r28, r17 704: d0 e0 ldi r29, 0x00 ; 0 706: c2 2b or r28, r18 708: d3 2b or r29, r19 70a: d0 93 2e 01 sts 0x012E, r29 70e: c0 93 2d 01 sts 0x012D, r28 // read the packet length (see datasheet page 43) len = enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0); 712: 8a e3 ldi r24, 0x3A ; 58 714: 60 e0 ldi r22, 0x00 ; 0 716: 0e 94 36 01 call 0x26c ; 0x26c 71a: e8 2e mov r14, r24 len |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8; 71c: 8a e3 ldi r24, 0x3A ; 58 71e: 60 e0 ldi r22, 0x00 ; 0 720: 0e 94 36 01 call 0x26c ; 0x26c 724: 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); 726: 8a e3 ldi r24, 0x3A ; 58 728: 60 e0 ldi r22, 0x00 ; 0 72a: 0e 94 36 01 call 0x26c ; 0x26c 72e: 08 2f mov r16, r24 730: 10 e0 ldi r17, 0x00 ; 0 rxstat |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8; 732: 8a e3 ldi r24, 0x3A ; 58 734: 60 e0 ldi r22, 0x00 ; 0 736: 0e 94 36 01 call 0x26c ; 0x26c 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){ 73a: 38 2f mov r19, r24 73c: 20 e0 ldi r18, 0x00 ; 0 73e: 20 2b or r18, r16 740: 31 2b or r19, r17 742: 27 fd sbrc r18, 7 744: 03 c0 rjmp .+6 ; 0x74c 746: 00 e0 ldi r16, 0x00 ; 0 748: 10 e0 ldi r17, 0x00 ; 0 74a: 12 c0 rjmp .+36 ; 0x770 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); 74c: 0e 2d mov r16, r14 74e: 10 e0 ldi r17, 0x00 ; 0 len |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8; 750: 9f 2d mov r25, r15 752: 80 e0 ldi r24, 0x00 ; 0 754: 08 2b or r16, r24 756: 19 2b or r17, r25 len-=4; //remove the CRC count 758: c6 01 movw r24, r12 75a: 01 97 sbiw r24, 0x01 ; 1 75c: 04 50 subi r16, 0x04 ; 4 75e: 10 40 sbci r17, 0x00 ; 0 760: 80 17 cp r24, r16 762: 91 07 cpc r25, r17 764: 08 f4 brcc .+2 ; 0x768 766: 8c 01 movw r16, r24 if ((rxstat & 0x80)==0){ // invalid len=0; }else{ // copy the packet from the receive buffer enc28j60ReadBuffer(len, packet); 768: c8 01 movw r24, r16 76a: b5 01 movw r22, r10 76c: 0e 94 58 01 call 0x2b0 ; 0x2b0 } // Move the RX read pointer to the start of the next received packet // This frees the memory we just read out enc28j60Write(ERXRDPTL, (NextPacketPtr)); 770: 8c e0 ldi r24, 0x0C ; 12 772: 6c 2f mov r22, r28 774: 0e 94 b7 01 call 0x36e ; 0x36e enc28j60Write(ERXRDPTH, (NextPacketPtr)>>8); 778: 8d e0 ldi r24, 0x0D ; 13 77a: 6d 2f mov r22, r29 77c: 0e 94 b7 01 call 0x36e ; 0x36e // decrement the packet counter indicate we are done with this packet enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON2, ECON2_PKTDEC); 780: 80 e8 ldi r24, 0x80 ; 128 782: 6e e1 ldi r22, 0x1E ; 30 784: 40 e4 ldi r20, 0x40 ; 64 786: 0e 94 4b 01 call 0x296 ; 0x296 return(len); } 78a: c8 01 movw r24, r16 78c: df 91 pop r29 78e: cf 91 pop r28 790: 1f 91 pop r17 792: 0f 91 pop r16 794: ff 90 pop r15 796: ef 90 pop r14 798: df 90 pop r13 79a: cf 90 pop r12 79c: bf 90 pop r11 79e: af 90 pop r10 7a0: 08 95 ret 000007a2

: static uint8_t myip[4] = {192,168,1,25};// прописываем IP-адрес устройства #define BUFFER_SIZE 400// указываем размер буфера для приема данных static uint8_t buf[BUFFER_SIZE+1];//инициализируем массив данных для буфера static uint16_t myport=1200;//порт для UDP int main(void)// главная функция программы { char str[20]; 7a2: df 92 push r13 7a4: ef 92 push r14 7a6: ff 92 push r15 7a8: 0f 93 push r16 7aa: 1f 93 push r17 7ac: df 93 push r29 7ae: cf 93 push r28 7b0: cd b7 in r28, 0x3d ; 61 7b2: de b7 in r29, 0x3e ; 62 7b4: 64 97 sbiw r28, 0x14 ; 20 7b6: 0f b6 in r0, 0x3f ; 63 7b8: f8 94 cli 7ba: de bf out 0x3e, r29 ; 62 7bc: 0f be out 0x3f, r0 ; 63 7be: cd bf out 0x3d, r28 ; 61 PORTD=0x00; 7c0: 1b b8 out 0x0b, r1 ; 11 DDRD|=0xff; 7c2: 8a b1 in r24, 0x0a ; 10 7c4: 8f ef ldi r24, 0xFF ; 255 7c6: 8a b9 out 0x0a, r24 ; 10 uint16_t plen; CLKPR=(1< _delay_ms(10); enc28j60Init(mymac);//запускаем функцию инициализации ENC28J60 7da: 87 e1 ldi r24, 0x17 ; 23 7dc: 91 e0 ldi r25, 0x01 ; 1 7de: 0e 94 e3 01 call 0x3c6 ; 0x3c6 7e2: 00 e4 ldi r16, 0x40 ; 64 7e4: 1c e9 ldi r17, 0x9C ; 156 7e6: c8 01 movw r24, r16 7e8: 01 97 sbiw r24, 0x01 ; 1 7ea: f1 f7 brne .-4 ; 0x7e8 _delay_ms(20); enc28j60PhyWrite(PHLCON,0x476);//настраиваем режим работы светодиодов ENC28J60:один светодиод индицирует статус соединения,другой-передачу и прием 7ec: 84 e1 ldi r24, 0x14 ; 20 7ee: 66 e7 ldi r22, 0x76 ; 118 7f0: 74 e0 ldi r23, 0x04 ; 4 7f2: 0e 94 c5 01 call 0x38a ; 0x38a 7f6: c8 01 movw r24, r16 7f8: 01 97 sbiw r24, 0x01 ; 1 7fa: f1 f7 brne .-4 ; 0x7f8 _delay_ms(20); init_ip_arp(mymac,myip);//запускаем функцию присваивания MAC- адреса и IP-адреса для последующей передачи 7fc: 87 e1 ldi r24, 0x17 ; 23 7fe: 91 e0 ldi r25, 0x01 ; 1 800: 6d e1 ldi r22, 0x1D ; 29 802: 71 e0 ldi r23, 0x01 ; 1 804: 0e 94 a5 00 call 0x14a ; 0x14a PORTD=PORTD&(~(1<<7));// потушили светодиод D7 strcpy(str,"Diod_is_off");//записывает строку "Diod_is_off" в массив str goto ANSWER; } ANSWER: make_udp_reply_from_request(buf,str,strlen(str),myport);// отправили ответ UDP 808: 7e 01 movw r14, r28 80a: 08 94 sec 80c: e1 1c adc r14, r1 80e: f1 1c adc r15, r1 } if (buf[IP_PROTO_P]==IP_PROTO_UDP_V&&buf[UDP_DST_PORT_H_P]==4&&buf[UDP_DST_PORT_L_P]==0xb0)//если в принятых данных тип протокола в заголовке IP UDP и предназначен нам { if(buf[UDP_DATA_P]==49)//если получили число 1 { PORTD=0x80;//зажгли светодиод D7 810: 20 e8 ldi r18, 0x80 ; 128 812: d2 2e mov r13, r18 enc28j60PhyWrite(PHLCON,0x476);//настраиваем режим работы светодиодов ENC28J60:один светодиод индицирует статус соединения,другой-передачу и прием _delay_ms(20); init_ip_arp(mymac,myip);//запускаем функцию присваивания MAC- адреса и IP-адреса для последующей передачи while(1) { plen = enc28j60PacketReceive(BUFFER_SIZE, buf);//запускаем функцию приема пакетов от ENC28J60 814: 80 e9 ldi r24, 0x90 ; 144 816: 91 e0 ldi r25, 0x01 ; 1 818: 6f e2 ldi r22, 0x2F ; 47 81a: 71 e0 ldi r23, 0x01 ; 1 81c: 0e 94 57 03 call 0x6ae ; 0x6ae 820: 8c 01 movw r16, r24 if(plen==0)// если принятых данных нет 822: 00 97 sbiw r24, 0x00 ; 0 824: b9 f3 breq .-18 ; 0x814 { continue;//то перейти на начало цикла while } if(eth_type_is_arp_and_my_ip(buf,plen))// если полученные данные ARP-запрос,адресованный нам 826: 8f e2 ldi r24, 0x2F ; 47 828: 91 e0 ldi r25, 0x01 ; 1 82a: b8 01 movw r22, r16 82c: 0e 94 c5 00 call 0x18a ; 0x18a 830: 88 23 and r24, r24 832: 29 f0 breq .+10 ; 0x83e { make_arp_answer_from_request(buf);//то сгенерировать и отправить ARP-ответ 834: 8f e2 ldi r24, 0x2F ; 47 836: 91 e0 ldi r25, 0x01 ; 1 838: 0e 94 2f 03 call 0x65e ; 0x65e 83c: eb cf rjmp .-42 ; 0x814 continue;// перейти на начало цикла while } if(eth_type_is_ip_and_my_ip(buf,plen)==0)// если полученные данные являются ip-пакетом и адресованы не нам 83e: 8f e2 ldi r24, 0x2F ; 47 840: 91 e0 ldi r25, 0x01 ; 1 842: b8 01 movw r22, r16 844: 0e 94 e1 00 call 0x1c2 ; 0x1c2 848: 88 23 and r24, r24 84a: 21 f3 breq .-56 ; 0x814 { continue;// перейти на начало цикла while } if(buf[IP_PROTO_P]==IP_PROTO_ICMP_V && buf[ICMP_TYPE_P]==ICMP_TYPE_ECHOREQUEST_V)//если в полученном ip-пакете содержится запрос "пинг" 84c: 80 91 46 01 lds r24, 0x0146 850: 81 30 cpi r24, 0x01 ; 1 852: 51 f4 brne .+20 ; 0x868 854: 80 91 51 01 lds r24, 0x0151 858: 88 30 cpi r24, 0x08 ; 8 85a: e1 f6 brne .-72 ; 0x814 { make_echo_reply_from_request(buf,plen);// отправим ответ "понг" 85c: 8f e2 ldi r24, 0x2F ; 47 85e: 91 e0 ldi r25, 0x01 ; 1 860: b8 01 movw r22, r16 862: 0e 94 11 03 call 0x622 ; 0x622 866: d6 cf rjmp .-84 ; 0x814 continue;//перейти на начало цикла while } if (buf[IP_PROTO_P]==IP_PROTO_UDP_V&&buf[UDP_DST_PORT_H_P]==4&&buf[UDP_DST_PORT_L_P]==0xb0)//если в принятых данных тип протокола в заголовке IP UDP и предназначен нам 868: 81 31 cpi r24, 0x11 ; 17 86a: a1 f6 brne .-88 ; 0x814 86c: 80 91 53 01 lds r24, 0x0153 870: 84 30 cpi r24, 0x04 ; 4 872: 81 f6 brne .-96 ; 0x814 874: 80 91 54 01 lds r24, 0x0154 878: 80 3b cpi r24, 0xB0 ; 176 87a: 61 f6 brne .-104 ; 0x814 { if(buf[UDP_DATA_P]==49)//если получили число 1 87c: 80 91 59 01 lds r24, 0x0159 880: 81 33 cpi r24, 0x31 ; 49 882: 29 f4 brne .+10 ; 0x88e { PORTD=0x80;//зажгли светодиод D7 884: db b8 out 0x0b, r13 ; 11 strcpy(str,"Diod_is_on");//записывает строку "Diod_is_on" в массив str 886: c7 01 movw r24, r14 888: 60 e0 ldi r22, 0x00 ; 0 88a: 71 e0 ldi r23, 0x01 ; 1 88c: 06 c0 rjmp .+12 ; 0x89a goto ANSWER; } if(buf[UDP_DATA_P]==48)// если получили число 0 88e: 80 33 cpi r24, 0x30 ; 48 890: 31 f4 brne .+12 ; 0x89e { PORTD=PORTD&(~(1<<7));// потушили светодиод D7 892: 5f 98 cbi 0x0b, 7 ; 11 strcpy(str,"Diod_is_off");//записывает строку "Diod_is_off" в массив str 894: c7 01 movw r24, r14 896: 6b e0 ldi r22, 0x0B ; 11 898: 71 e0 ldi r23, 0x01 ; 1 89a: 0e 94 5f 04 call 0x8be ; 0x8be goto ANSWER; } ANSWER: make_udp_reply_from_request(buf,str,strlen(str),myport);// отправили ответ UDP 89e: f7 01 movw r30, r14 8a0: 01 90 ld r0, Z+ 8a2: 00 20 and r0, r0 8a4: e9 f7 brne .-6 ; 0x8a0 8a6: 31 97 sbiw r30, 0x01 ; 1 8a8: ee 19 sub r30, r14 8aa: ff 09 sbc r31, r15 8ac: 8f e2 ldi r24, 0x2F ; 47 8ae: 91 e0 ldi r25, 0x01 ; 1 8b0: b7 01 movw r22, r14 8b2: 4e 2f mov r20, r30 8b4: 20 eb ldi r18, 0xB0 ; 176 8b6: 34 e0 ldi r19, 0x04 ; 4 8b8: 0e 94 cb 02 call 0x596 ; 0x596 8bc: ab cf rjmp .-170 ; 0x814 000008be : 8be: fb 01 movw r30, r22 8c0: dc 01 movw r26, r24 8c2: 01 90 ld r0, Z+ 8c4: 0d 92 st X+, r0 8c6: 00 20 and r0, r0 8c8: e1 f7 brne .-8 ; 0x8c2 8ca: 08 95 ret 000008cc <_exit>: 8cc: f8 94 cli 000008ce <__stop_program>: 8ce: ff cf rjmp .-2 ; 0x8ce <__stop_program>