
aqua_stop.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         00000d58  00000000  00000000  00000094  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .data         00000146  00800060  00000d58  00000dec  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  2 .bss          0000001b  008001a6  008001a6  00000f32  2**0
                  ALLOC
  3 .debug_aranges 00000020  00000000  00000000  00000f32  2**0
                  CONTENTS, READONLY, DEBUGGING
  4 .debug_pubnames 000001e4  00000000  00000000  00000f52  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_info   0000055c  00000000  00000000  00001136  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_abbrev 000001f0  00000000  00000000  00001692  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_line   00000b3d  00000000  00000000  00001882  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_frame  00000130  00000000  00000000  000023c0  2**2
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_str    00000214  00000000  00000000  000024f0  2**0
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_loc    00000226  00000000  00000000  00002704  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
   0:	0c 94 2a 00 	jmp	0x54	; 0x54 <__ctors_end>
   4:	0c 94 93 04 	jmp	0x926	; 0x926 <__vector_1>
   8:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
   c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  10:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  14:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  18:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  1c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  20:	0c 94 ff 02 	jmp	0x5fe	; 0x5fe <__vector_8>
  24:	0c 94 28 02 	jmp	0x450	; 0x450 <__vector_9>
  28:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  2c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  30:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  34:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  38:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  3c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  40:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  44:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  48:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  4c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  50:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>

00000054 <__ctors_end>:
  54:	11 24       	eor	r1, r1
  56:	1f be       	out	0x3f, r1	; 63
  58:	cf e5       	ldi	r28, 0x5F	; 95
  5a:	d4 e0       	ldi	r29, 0x04	; 4
  5c:	de bf       	out	0x3e, r29	; 62
  5e:	cd bf       	out	0x3d, r28	; 61

00000060 <__do_copy_data>:
  60:	11 e0       	ldi	r17, 0x01	; 1
  62:	a0 e6       	ldi	r26, 0x60	; 96
  64:	b0 e0       	ldi	r27, 0x00	; 0
  66:	e8 e5       	ldi	r30, 0x58	; 88
  68:	fd e0       	ldi	r31, 0x0D	; 13
  6a:	02 c0       	rjmp	.+4      	; 0x70 <.do_copy_data_start>

0000006c <.do_copy_data_loop>:
  6c:	05 90       	lpm	r0, Z+
  6e:	0d 92       	st	X+, r0

00000070 <.do_copy_data_start>:
  70:	a6 3a       	cpi	r26, 0xA6	; 166
  72:	b1 07       	cpc	r27, r17
  74:	d9 f7       	brne	.-10     	; 0x6c <.do_copy_data_loop>

00000076 <__do_clear_bss>:
  76:	11 e0       	ldi	r17, 0x01	; 1
  78:	a6 ea       	ldi	r26, 0xA6	; 166
  7a:	b1 e0       	ldi	r27, 0x01	; 1
  7c:	01 c0       	rjmp	.+2      	; 0x80 <.do_clear_bss_start>

0000007e <.do_clear_bss_loop>:
  7e:	1d 92       	st	X+, r1

00000080 <.do_clear_bss_start>:
  80:	a1 3c       	cpi	r26, 0xC1	; 193
  82:	b1 07       	cpc	r27, r17
  84:	e1 f7       	brne	.-8      	; 0x7e <.do_clear_bss_loop>
  86:	0e 94 53 06 	call	0xca6	; 0xca6 <main>
  8a:	0c 94 aa 06 	jmp	0xd54	; 0xd54 <_exit>

0000008e <__bad_interrupt>:
  8e:	0c 94 00 00 	jmp	0	; 0x0 <__vectors>

00000092 <USART_Init>:

void USART_Init(unsigned int baud )
{
#define UBRRVAL ((F_CPU/(baud*16UL))-1)
//Set baud rate
UBRRL=UBRRVAL;		//low byte
  92:	9c 01       	movw	r18, r24
  94:	40 e0       	ldi	r20, 0x00	; 0
  96:	50 e0       	ldi	r21, 0x00	; 0
  98:	22 0f       	add	r18, r18
  9a:	33 1f       	adc	r19, r19
  9c:	44 1f       	adc	r20, r20
  9e:	55 1f       	adc	r21, r21
  a0:	22 0f       	add	r18, r18
  a2:	33 1f       	adc	r19, r19
  a4:	44 1f       	adc	r20, r20
  a6:	55 1f       	adc	r21, r21
  a8:	22 0f       	add	r18, r18
  aa:	33 1f       	adc	r19, r19
  ac:	44 1f       	adc	r20, r20
  ae:	55 1f       	adc	r21, r21
  b0:	22 0f       	add	r18, r18
  b2:	33 1f       	adc	r19, r19
  b4:	44 1f       	adc	r20, r20
  b6:	55 1f       	adc	r21, r21
  b8:	60 e0       	ldi	r22, 0x00	; 0
  ba:	72 e1       	ldi	r23, 0x12	; 18
  bc:	8a e7       	ldi	r24, 0x7A	; 122
  be:	90 e0       	ldi	r25, 0x00	; 0
  c0:	0e 94 73 06 	call	0xce6	; 0xce6 <__udivmodsi4>
  c4:	82 2f       	mov	r24, r18
  c6:	93 2f       	mov	r25, r19
  c8:	a4 2f       	mov	r26, r20
  ca:	b5 2f       	mov	r27, r21
  cc:	21 50       	subi	r18, 0x01	; 1
  ce:	29 b9       	out	0x09, r18	; 9
UBRRH=(UBRRVAL>>8);	//high byte
  d0:	01 97       	sbiw	r24, 0x01	; 1
  d2:	a1 09       	sbc	r26, r1
  d4:	b1 09       	sbc	r27, r1
  d6:	89 2f       	mov	r24, r25
  d8:	9a 2f       	mov	r25, r26
  da:	ab 2f       	mov	r26, r27
  dc:	bb 27       	eor	r27, r27
  de:	e0 e4       	ldi	r30, 0x40	; 64
  e0:	f0 e0       	ldi	r31, 0x00	; 0
  e2:	80 83       	st	Z, r24
//Set data frame format: asynchronous mode,no parity, 1 stop bit, 8 bit size
UCSRC=(1<<URSEL)|(0<<UMSEL)|(0<<UPM1)|(0<<UPM0)|	(0<<USBS)|(0<<UCSZ2)|(1<<UCSZ1)|(1<<UCSZ0);
  e4:	86 e8       	ldi	r24, 0x86	; 134
  e6:	80 83       	st	Z, r24
//Enable Transmitter and Receiver
UCSRB=(1<<RXEN)|(1<<TXEN)|(1<<RXCIE);
  e8:	88 e9       	ldi	r24, 0x98	; 152
  ea:	8a b9       	out	0x0a, r24	; 10
}
  ec:	08 95       	ret

000000ee <USART_Send>:

//функция выдает в порт RS232 один символ
void USART_Send( unsigned int Txt )
{
  ee:	98 2f       	mov	r25, r24
  while (!(UCSRA&(1<<UDRE))){};
  f0:	eb e2       	ldi	r30, 0x2B	; 43
  f2:	f0 e0       	ldi	r31, 0x00	; 0
  f4:	80 81       	ld	r24, Z
  f6:	85 ff       	sbrs	r24, 5
  f8:	fd cf       	rjmp	.-6      	; 0xf4 <USART_Send+0x6>
  UDR=Txt;		//send number to USART
  fa:	9c b9       	out	0x0c, r25	; 12
}
  fc:	08 95       	ret

000000fe <USART_Send_srt>:

//функция выдает в порт RS232 строку из сомволов
void USART_Send_srt(char* pTxT)
{
  fe:	cf 93       	push	r28
 100:	df 93       	push	r29
 102:	ec 01       	movw	r28, r24
//unsigned char i=0;
 USART_Send(10);
 104:	8a e0       	ldi	r24, 0x0A	; 10
 106:	90 e0       	ldi	r25, 0x00	; 0
 108:	0e 94 77 00 	call	0xee	; 0xee <USART_Send>
 while( 1 )
 {
  if (! (*pTxT) )
 10c:	88 81       	ld	r24, Y
 10e:	88 23       	and	r24, r24
 110:	59 f4       	brne	.+22     	; 0x128 <USART_Send_srt+0x2a>
  {
   USART_Send(10);
 112:	8a e0       	ldi	r24, 0x0A	; 10
 114:	90 e0       	ldi	r25, 0x00	; 0
 116:	0e 94 77 00 	call	0xee	; 0xee <USART_Send>
   USART_Send(13);
 11a:	8d e0       	ldi	r24, 0x0D	; 13
 11c:	90 e0       	ldi	r25, 0x00	; 0
 11e:	0e 94 77 00 	call	0xee	; 0xee <USART_Send>
   break;
  }
   USART_Send((int)(*pTxT));
   ++pTxT;
 }
}
 122:	df 91       	pop	r29
 124:	cf 91       	pop	r28
 126:	08 95       	ret
  {
   USART_Send(10);
   USART_Send(13);
   break;
  }
   USART_Send((int)(*pTxT));
 128:	90 e0       	ldi	r25, 0x00	; 0
 12a:	0e 94 77 00 	call	0xee	; 0xee <USART_Send>
   ++pTxT;
 12e:	21 96       	adiw	r28, 0x01	; 1
{
//unsigned char i=0;
 USART_Send(10);
 while( 1 )
 {
  if (! (*pTxT) )
 130:	88 81       	ld	r24, Y
 132:	88 23       	and	r24, r24
 134:	c9 f7       	brne	.-14     	; 0x128 <USART_Send_srt+0x2a>
 136:	ed cf       	rjmp	.-38     	; 0x112 <USART_Send_srt+0x14>

00000138 <tap_setting>:
}

void tap_setting(void){
// установка статусов кранов в зависимости от состояния массива

if (tap_status[0]==1){
 138:	80 91 a6 01 	lds	r24, 0x01A6
 13c:	81 30       	cpi	r24, 0x01	; 1
 13e:	31 f4       	brne	.+12     	; 0x14c <tap_setting+0x14>
 cold_tap_on; // (закрываем кран)
 140:	e2 e3       	ldi	r30, 0x32	; 50
 142:	f0 e0       	ldi	r31, 0x00	; 0
 144:	80 81       	ld	r24, Z
 146:	80 64       	ori	r24, 0x40	; 64
 148:	80 83       	st	Z, r24
 14a:	05 c0       	rjmp	.+10     	; 0x156 <tap_setting+0x1e>
}else{
 cold_tap_off; // (открываем кран)
 14c:	e2 e3       	ldi	r30, 0x32	; 50
 14e:	f0 e0       	ldi	r31, 0x00	; 0
 150:	80 81       	ld	r24, Z
 152:	8f 7b       	andi	r24, 0xBF	; 191
 154:	80 83       	st	Z, r24
}

if (tap_status[1]==1){
 156:	80 91 a7 01 	lds	r24, 0x01A7
 15a:	81 30       	cpi	r24, 0x01	; 1
 15c:	31 f4       	brne	.+12     	; 0x16a <tap_setting+0x32>
 hot_tap_on; // (закрываем кран)
 15e:	e2 e3       	ldi	r30, 0x32	; 50
 160:	f0 e0       	ldi	r31, 0x00	; 0
 162:	80 81       	ld	r24, Z
 164:	80 62       	ori	r24, 0x20	; 32
 166:	80 83       	st	Z, r24
 168:	08 95       	ret
}else{
 hot_tap_off; // (открываем кран)
 16a:	e2 e3       	ldi	r30, 0x32	; 50
 16c:	f0 e0       	ldi	r31, 0x00	; 0
 16e:	80 81       	ld	r24, Z
 170:	8f 7d       	andi	r24, 0xDF	; 223
 172:	80 83       	st	Z, r24
 174:	08 95       	ret

00000176 <input_check>:
} 

}

void input_check(void){
 176:	2f 92       	push	r2
 178:	3f 92       	push	r3
 17a:	4f 92       	push	r4
 17c:	5f 92       	push	r5
 17e:	6f 92       	push	r6
 180:	7f 92       	push	r7
 182:	8f 92       	push	r8
 184:	9f 92       	push	r9
 186:	af 92       	push	r10
 188:	bf 92       	push	r11
 18a:	cf 92       	push	r12
 18c:	df 92       	push	r13
 18e:	ef 92       	push	r14
 190:	ff 92       	push	r15
 192:	0f 93       	push	r16
 194:	1f 93       	push	r17
 196:	cf 93       	push	r28
 198:	df 93       	push	r29
 19a:	c1 e0       	ldi	r28, 0x01	; 1
 19c:	d0 e0       	ldi	r29, 0x00	; 0
// проверяем состояние входов, поднимаем аварию и изменяем состояние светодидов
unsigned int i;	
for (i=0;i<max_in;i++){ // перебираем массив с настройками входов
 if ((In_status[i]==1)) { //вход мониторится 
 19e:	0f 2e       	mov	r0, r31
 1a0:	fe e9       	ldi	r31, 0x9E	; 158
 1a2:	ef 2e       	mov	r14, r31
 1a4:	f1 e0       	ldi	r31, 0x01	; 1
 1a6:	ff 2e       	mov	r15, r31
 1a8:	f0 2d       	mov	r31, r0
		   }else if ((in3==2) && (led_status[i]==2)){  // по входу протечка исчезла, начинаем мигать светодиодом
		    led_status[i]=3;
		    USART_Send_srt("IN3 BLINK ALARM");
		   }
		   break;// проверяем что на входе3 низкий уровень и выставляем пищалку и меняем состояние входа светодидода
   case 3: if ((in4==0) && (led_status[i]<2)) {
 1aa:	06 e3       	ldi	r16, 0x36	; 54
 1ac:	10 e0       	ldi	r17, 0x00	; 0
            beep_count=60; // выставляем пищалку 
 1ae:	0f 2e       	mov	r0, r31
 1b0:	fc e3       	ldi	r31, 0x3C	; 60
 1b2:	9f 2e       	mov	r9, r31
 1b4:	f0 2d       	mov	r31, r0
			led_status[i]=2; // и меняем состояние входа светодидода
 1b6:	88 24       	eor	r8, r8
 1b8:	68 94       	set
 1ba:	81 f8       	bld	r8, 1
			alarm=1; // поднимаем флаг аварии
 1bc:	77 24       	eor	r7, r7
 1be:	73 94       	inc	r7
		   }else if ((in5==1) && (led_status[i]==2)){ // по входу протечка исчезла, начинаем мигать светодиодом
		    led_status[i]=3;
		    USART_Send_srt("IN5 BLINK ALARM");
		   }
		   break;
   case 5: if ((in6==0) && (led_status[i]<2)) {
 1c0:	0f 2e       	mov	r0, r31
 1c2:	fd ea       	ldi	r31, 0xAD	; 173
 1c4:	4f 2e       	mov	r4, r31
 1c6:	f1 e0       	ldi	r31, 0x01	; 1
 1c8:	5f 2e       	mov	r5, r31
 1ca:	f0 2d       	mov	r31, r0
   case 4: if ((in5==0) && (led_status[i]<2)) {
            beep_count=60; // выставляем пищалку 
			led_status[i]=2; // и меняем состояние входа светодидода
			alarm=1; // поднимаем флаг аварии
		    USART_Send_srt("IN5 ALARM");
		   }else if ((in5==1) && (led_status[i]==2)){ // по входу протечка исчезла, начинаем мигать светодиодом
 1cc:	0f 2e       	mov	r0, r31
 1ce:	fc ea       	ldi	r31, 0xAC	; 172
 1d0:	af 2e       	mov	r10, r31
 1d2:	f1 e0       	ldi	r31, 0x01	; 1
 1d4:	bf 2e       	mov	r11, r31
 1d6:	f0 2d       	mov	r31, r0
		    led_status[i]=3;
 1d8:	0f 2e       	mov	r0, r31
 1da:	f3 e0       	ldi	r31, 0x03	; 3
 1dc:	6f 2e       	mov	r6, r31
 1de:	f0 2d       	mov	r31, r0
		   }else if ((in6==2) && (led_status[i]==2)){ // по входу протечка исчезла, начинаем мигать светодиодом
		    led_status[i]=3;
		    USART_Send_srt("IN6 BLINK ALARM");
		   }
		   break;
   case 6: if ((in7==0) && (led_status[i]<2)) {
 1e0:	0f 2e       	mov	r0, r31
 1e2:	fe ea       	ldi	r31, 0xAE	; 174
 1e4:	2f 2e       	mov	r2, r31
 1e6:	f1 e0       	ldi	r31, 0x01	; 1
 1e8:	3f 2e       	mov	r3, r31
 1ea:	f0 2d       	mov	r31, r0
   case 0: if ((in1==0) && (led_status[i]<2)) { // по входу обнаружена протечка и по нему не было протечек ранее (т.е. два раза не реагируем на один и тот же датчик)
            beep_count=60; // выставляем пищалку 
			led_status[i]=2; // и меняем состояние входа светодидода
			alarm=1; // поднимаем флаг аварии
		    USART_Send_srt("IN1 ALARM");
		   }else if ((in1==1) && (led_status[i]==2)){ // по входу протечка исчезла, начинаем мигать светодиодом
 1ec:	0f 2e       	mov	r0, r31
 1ee:	f8 ea       	ldi	r31, 0xA8	; 168
 1f0:	cf 2e       	mov	r12, r31
 1f2:	f1 e0       	ldi	r31, 0x01	; 1
 1f4:	df 2e       	mov	r13, r31
 1f6:	f0 2d       	mov	r31, r0
 1f8:	01 c0       	rjmp	.+2      	; 0x1fc <input_check+0x86>
 hot_tap_off; // (открываем кран)
} 

}

void input_check(void){
 1fa:	21 96       	adiw	r28, 0x01	; 1
 1fc:	9e 01       	movw	r18, r28
 1fe:	21 50       	subi	r18, 0x01	; 1
 200:	30 40       	sbci	r19, 0x00	; 0
// проверяем состояние входов, поднимаем аварию и изменяем состояние светодидов
unsigned int i;	
for (i=0;i<max_in;i++){ // перебираем массив с настройками входов
 if ((In_status[i]==1)) { //вход мониторится 
 202:	f7 01       	movw	r30, r14
 204:	ec 0f       	add	r30, r28
 206:	fd 1f       	adc	r31, r29
 208:	31 97       	sbiw	r30, 0x01	; 1
 20a:	80 81       	ld	r24, Z
 20c:	81 30       	cpi	r24, 0x01	; 1
 20e:	09 f0       	breq	.+2      	; 0x212 <input_check+0x9c>
 210:	e7 c0       	rjmp	.+462    	; 0x3e0 <input_check+0x26a>
  switch (i){
 212:	23 30       	cpi	r18, 0x03	; 3
 214:	31 05       	cpc	r19, r1
 216:	09 f4       	brne	.+2      	; 0x21a <input_check+0xa4>
 218:	69 c0       	rjmp	.+210    	; 0x2ec <input_check+0x176>
 21a:	24 30       	cpi	r18, 0x04	; 4
 21c:	31 05       	cpc	r19, r1
 21e:	40 f4       	brcc	.+16     	; 0x230 <input_check+0xba>
 220:	21 30       	cpi	r18, 0x01	; 1
 222:	31 05       	cpc	r19, r1
 224:	b9 f1       	breq	.+110    	; 0x294 <input_check+0x11e>
 226:	22 30       	cpi	r18, 0x02	; 2
 228:	31 05       	cpc	r19, r1
 22a:	08 f0       	brcs	.+2      	; 0x22e <input_check+0xb8>
 22c:	49 c0       	rjmp	.+146    	; 0x2c0 <input_check+0x14a>
 22e:	11 c0       	rjmp	.+34     	; 0x252 <input_check+0xdc>
 230:	25 30       	cpi	r18, 0x05	; 5
 232:	31 05       	cpc	r19, r1
 234:	09 f4       	brne	.+2      	; 0x238 <input_check+0xc2>
 236:	91 c0       	rjmp	.+290    	; 0x35a <input_check+0x1e4>
 238:	25 30       	cpi	r18, 0x05	; 5
 23a:	31 05       	cpc	r19, r1
 23c:	08 f4       	brcc	.+2      	; 0x240 <input_check+0xca>
 23e:	6c c0       	rjmp	.+216    	; 0x318 <input_check+0x1a2>
 240:	26 30       	cpi	r18, 0x06	; 6
 242:	31 05       	cpc	r19, r1
 244:	09 f4       	brne	.+2      	; 0x248 <input_check+0xd2>
 246:	9e c0       	rjmp	.+316    	; 0x384 <input_check+0x20e>
 248:	27 30       	cpi	r18, 0x07	; 7
 24a:	31 05       	cpc	r19, r1
 24c:	09 f0       	breq	.+2      	; 0x250 <input_check+0xda>
 24e:	c8 c0       	rjmp	.+400    	; 0x3e0 <input_check+0x26a>
 250:	ae c0       	rjmp	.+348    	; 0x3ae <input_check+0x238>
   case 0: if ((in1==0) && (led_status[i]<2)) { // по входу обнаружена протечка и по нему не было протечек ранее (т.е. два раза не реагируем на один и тот же датчик)
 252:	f8 01       	movw	r30, r16
 254:	80 81       	ld	r24, Z
 256:	80 fd       	sbrc	r24, 0
 258:	0e c0       	rjmp	.+28     	; 0x276 <input_check+0x100>
 25a:	f6 01       	movw	r30, r12
 25c:	80 81       	ld	r24, Z
 25e:	82 30       	cpi	r24, 0x02	; 2
 260:	50 f4       	brcc	.+20     	; 0x276 <input_check+0x100>
            beep_count=60; // выставляем пищалку 
 262:	90 92 b1 01 	sts	0x01B1, r9
			led_status[i]=2; // и меняем состояние входа светодидода
 266:	80 82       	st	Z, r8
			alarm=1; // поднимаем флаг аварии
 268:	70 92 b2 01 	sts	0x01B2, r7
		    USART_Send_srt("IN1 ALARM");
 26c:	80 e6       	ldi	r24, 0x60	; 96
 26e:	90 e0       	ldi	r25, 0x00	; 0
 270:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 274:	c2 cf       	rjmp	.-124    	; 0x1fa <input_check+0x84>
		   }else if ((in1==1) && (led_status[i]==2)){ // по входу протечка исчезла, начинаем мигать светодиодом
 276:	f8 01       	movw	r30, r16
 278:	80 81       	ld	r24, Z
 27a:	80 ff       	sbrs	r24, 0
 27c:	b1 c0       	rjmp	.+354    	; 0x3e0 <input_check+0x26a>
 27e:	f6 01       	movw	r30, r12
 280:	80 81       	ld	r24, Z
 282:	82 30       	cpi	r24, 0x02	; 2
 284:	09 f0       	breq	.+2      	; 0x288 <input_check+0x112>
 286:	ac c0       	rjmp	.+344    	; 0x3e0 <input_check+0x26a>
		    led_status[i]=3;
 288:	60 82       	st	Z, r6
		    USART_Send_srt("IN1 BLINK ALARM");
 28a:	8a e6       	ldi	r24, 0x6A	; 106
 28c:	90 e0       	ldi	r25, 0x00	; 0
 28e:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 292:	a6 c0       	rjmp	.+332    	; 0x3e0 <input_check+0x26a>
		   }
		   break;
   case 1: if ((in2==0) && (led_status[i]<2)) {
 294:	f8 01       	movw	r30, r16
 296:	80 81       	ld	r24, Z
 298:	81 fd       	sbrc	r24, 1
 29a:	0f c0       	rjmp	.+30     	; 0x2ba <input_check+0x144>
 29c:	e9 ea       	ldi	r30, 0xA9	; 169
 29e:	f1 e0       	ldi	r31, 0x01	; 1
 2a0:	80 81       	ld	r24, Z
 2a2:	82 30       	cpi	r24, 0x02	; 2
 2a4:	50 f4       	brcc	.+20     	; 0x2ba <input_check+0x144>
            beep_count=60; 
 2a6:	90 92 b1 01 	sts	0x01B1, r9
			led_status[i]=2;
 2aa:	80 82       	st	Z, r8
			alarm=1;
 2ac:	70 92 b2 01 	sts	0x01B2, r7
		    USART_Send_srt("IN2 ALARM");
 2b0:	8a e7       	ldi	r24, 0x7A	; 122
 2b2:	90 e0       	ldi	r25, 0x00	; 0
 2b4:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 2b8:	a0 cf       	rjmp	.-192    	; 0x1fa <input_check+0x84>
		   }else if ((in1==2) && (led_status[i]==2)){ // по входу протечка исчезла, начинаем мигать светодиодом
 2ba:	f8 01       	movw	r30, r16
 2bc:	80 81       	ld	r24, Z
 2be:	90 c0       	rjmp	.+288    	; 0x3e0 <input_check+0x26a>
		    led_status[i]=3;
		    USART_Send_srt("IN2 BLINK ALARM");
		   }
		   break;// проверяем что на входе2 низкий уровень и выставляем пищалку и меняем состояние входа светодидода
   case 2: if ((in3==0) && (led_status[i]<2)) {
 2c0:	f8 01       	movw	r30, r16
 2c2:	80 81       	ld	r24, Z
 2c4:	82 fd       	sbrc	r24, 2
 2c6:	0f c0       	rjmp	.+30     	; 0x2e6 <input_check+0x170>
 2c8:	ea ea       	ldi	r30, 0xAA	; 170
 2ca:	f1 e0       	ldi	r31, 0x01	; 1
 2cc:	80 81       	ld	r24, Z
 2ce:	82 30       	cpi	r24, 0x02	; 2
 2d0:	50 f4       	brcc	.+20     	; 0x2e6 <input_check+0x170>
            beep_count=60; 
 2d2:	90 92 b1 01 	sts	0x01B1, r9
			led_status[i]=2;
 2d6:	80 82       	st	Z, r8
			alarm=1;
 2d8:	70 92 b2 01 	sts	0x01B2, r7
		    USART_Send_srt("IN3 ALARM");
 2dc:	84 e8       	ldi	r24, 0x84	; 132
 2de:	90 e0       	ldi	r25, 0x00	; 0
 2e0:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 2e4:	8a cf       	rjmp	.-236    	; 0x1fa <input_check+0x84>
		   }else if ((in3==2) && (led_status[i]==2)){  // по входу протечка исчезла, начинаем мигать светодиодом
 2e6:	f8 01       	movw	r30, r16
 2e8:	80 81       	ld	r24, Z
 2ea:	7a c0       	rjmp	.+244    	; 0x3e0 <input_check+0x26a>
		    led_status[i]=3;
		    USART_Send_srt("IN3 BLINK ALARM");
		   }
		   break;// проверяем что на входе3 низкий уровень и выставляем пищалку и меняем состояние входа светодидода
   case 3: if ((in4==0) && (led_status[i]<2)) {
 2ec:	f8 01       	movw	r30, r16
 2ee:	80 81       	ld	r24, Z
 2f0:	83 fd       	sbrc	r24, 3
 2f2:	0f c0       	rjmp	.+30     	; 0x312 <input_check+0x19c>
 2f4:	eb ea       	ldi	r30, 0xAB	; 171
 2f6:	f1 e0       	ldi	r31, 0x01	; 1
 2f8:	80 81       	ld	r24, Z
 2fa:	82 30       	cpi	r24, 0x02	; 2
 2fc:	50 f4       	brcc	.+20     	; 0x312 <input_check+0x19c>
            beep_count=60; // выставляем пищалку 
 2fe:	90 92 b1 01 	sts	0x01B1, r9
			led_status[i]=2; // и меняем состояние входа светодидода
 302:	80 82       	st	Z, r8
			alarm=1; // поднимаем флаг аварии
 304:	70 92 b2 01 	sts	0x01B2, r7
		    USART_Send_srt("IN4 ALARM");
 308:	8e e8       	ldi	r24, 0x8E	; 142
 30a:	90 e0       	ldi	r25, 0x00	; 0
 30c:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 310:	74 cf       	rjmp	.-280    	; 0x1fa <input_check+0x84>
		   }else if ((in4==2) && (led_status[i]==2)){ // по входу протечка исчезла, начинаем мигать светодиодом
 312:	f8 01       	movw	r30, r16
 314:	80 81       	ld	r24, Z
 316:	64 c0       	rjmp	.+200    	; 0x3e0 <input_check+0x26a>
		    led_status[i]=3;
		    USART_Send_srt("IN4 BLINK ALARM");
		   }
		   break;
   case 4: if ((in5==0) && (led_status[i]<2)) {
 318:	f8 01       	movw	r30, r16
 31a:	80 81       	ld	r24, Z
 31c:	84 fd       	sbrc	r24, 4
 31e:	0e c0       	rjmp	.+28     	; 0x33c <input_check+0x1c6>
 320:	f5 01       	movw	r30, r10
 322:	80 81       	ld	r24, Z
 324:	82 30       	cpi	r24, 0x02	; 2
 326:	50 f4       	brcc	.+20     	; 0x33c <input_check+0x1c6>
            beep_count=60; // выставляем пищалку 
 328:	90 92 b1 01 	sts	0x01B1, r9
			led_status[i]=2; // и меняем состояние входа светодидода
 32c:	80 82       	st	Z, r8
			alarm=1; // поднимаем флаг аварии
 32e:	70 92 b2 01 	sts	0x01B2, r7
		    USART_Send_srt("IN5 ALARM");
 332:	88 e9       	ldi	r24, 0x98	; 152
 334:	90 e0       	ldi	r25, 0x00	; 0
 336:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 33a:	5f cf       	rjmp	.-322    	; 0x1fa <input_check+0x84>
		   }else if ((in5==1) && (led_status[i]==2)){ // по входу протечка исчезла, начинаем мигать светодиодом
 33c:	f8 01       	movw	r30, r16
 33e:	80 81       	ld	r24, Z
 340:	84 ff       	sbrs	r24, 4
 342:	4e c0       	rjmp	.+156    	; 0x3e0 <input_check+0x26a>
 344:	f5 01       	movw	r30, r10
 346:	80 81       	ld	r24, Z
 348:	82 30       	cpi	r24, 0x02	; 2
 34a:	09 f0       	breq	.+2      	; 0x34e <input_check+0x1d8>
 34c:	49 c0       	rjmp	.+146    	; 0x3e0 <input_check+0x26a>
		    led_status[i]=3;
 34e:	60 82       	st	Z, r6
		    USART_Send_srt("IN5 BLINK ALARM");
 350:	82 ea       	ldi	r24, 0xA2	; 162
 352:	90 e0       	ldi	r25, 0x00	; 0
 354:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 358:	43 c0       	rjmp	.+134    	; 0x3e0 <input_check+0x26a>
		   }
		   break;
   case 5: if ((in6==0) && (led_status[i]<2)) {
 35a:	f8 01       	movw	r30, r16
 35c:	80 81       	ld	r24, Z
 35e:	85 fd       	sbrc	r24, 5
 360:	0e c0       	rjmp	.+28     	; 0x37e <input_check+0x208>
 362:	f2 01       	movw	r30, r4
 364:	80 81       	ld	r24, Z
 366:	82 30       	cpi	r24, 0x02	; 2
 368:	50 f4       	brcc	.+20     	; 0x37e <input_check+0x208>
            beep_count=60; // выставляем пищалку 
 36a:	90 92 b1 01 	sts	0x01B1, r9
			led_status[i]=2; // и меняем состояние входа светодидода
 36e:	80 82       	st	Z, r8
			alarm=1; // поднимаем флаг аварии
 370:	70 92 b2 01 	sts	0x01B2, r7
		    USART_Send_srt("IN6 ALARM");
 374:	82 eb       	ldi	r24, 0xB2	; 178
 376:	90 e0       	ldi	r25, 0x00	; 0
 378:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 37c:	3e cf       	rjmp	.-388    	; 0x1fa <input_check+0x84>
		   }else if ((in6==2) && (led_status[i]==2)){ // по входу протечка исчезла, начинаем мигать светодиодом
 37e:	f8 01       	movw	r30, r16
 380:	80 81       	ld	r24, Z
 382:	2e c0       	rjmp	.+92     	; 0x3e0 <input_check+0x26a>
		    led_status[i]=3;
		    USART_Send_srt("IN6 BLINK ALARM");
		   }
		   break;
   case 6: if ((in7==0) && (led_status[i]<2)) {
 384:	f8 01       	movw	r30, r16
 386:	80 81       	ld	r24, Z
 388:	86 fd       	sbrc	r24, 6
 38a:	0e c0       	rjmp	.+28     	; 0x3a8 <input_check+0x232>
 38c:	f1 01       	movw	r30, r2
 38e:	80 81       	ld	r24, Z
 390:	82 30       	cpi	r24, 0x02	; 2
 392:	50 f4       	brcc	.+20     	; 0x3a8 <input_check+0x232>
            beep_count=60; // выставляем пищалку 
 394:	90 92 b1 01 	sts	0x01B1, r9
			led_status[i]=2; // и меняем состояние входа светодидода
 398:	80 82       	st	Z, r8
			alarm=1; // поднимаем флаг аварии
 39a:	70 92 b2 01 	sts	0x01B2, r7
		    USART_Send_srt("IN7 ALARM");
 39e:	8c eb       	ldi	r24, 0xBC	; 188
 3a0:	90 e0       	ldi	r25, 0x00	; 0
 3a2:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 3a6:	29 cf       	rjmp	.-430    	; 0x1fa <input_check+0x84>
		   }else if ((in7==2) && (led_status[i]==2)){ // по входу протечка исчезла, начинаем мигать светодиодом
 3a8:	f8 01       	movw	r30, r16
 3aa:	80 81       	ld	r24, Z
 3ac:	19 c0       	rjmp	.+50     	; 0x3e0 <input_check+0x26a>
		    led_status[i]=3;
		    USART_Send_srt("IN7 BLINK ALARM");
		   }
		   break;
   case 7: if ((in8==0) && (led_status[i]<2)) {
 3ae:	f8 01       	movw	r30, r16
 3b0:	80 81       	ld	r24, Z
 3b2:	88 23       	and	r24, r24
 3b4:	9c f0       	brlt	.+38     	; 0x3dc <input_check+0x266>
 3b6:	ef ea       	ldi	r30, 0xAF	; 175
 3b8:	f1 e0       	ldi	r31, 0x01	; 1
 3ba:	80 81       	ld	r24, Z
 3bc:	82 30       	cpi	r24, 0x02	; 2
 3be:	70 f4       	brcc	.+28     	; 0x3dc <input_check+0x266>
            beep_count=60; // выставляем пищалку 
 3c0:	8c e3       	ldi	r24, 0x3C	; 60
 3c2:	80 93 b1 01 	sts	0x01B1, r24
			led_status[i]=2; // и меняем состояние входа светодидода
 3c6:	82 e0       	ldi	r24, 0x02	; 2
 3c8:	80 93 af 01 	sts	0x01AF, r24
			alarm=1; // поднимаем флаг аварии
 3cc:	81 e0       	ldi	r24, 0x01	; 1
 3ce:	80 93 b2 01 	sts	0x01B2, r24
		    USART_Send_srt("IN8 ALARM");
 3d2:	86 ec       	ldi	r24, 0xC6	; 198
 3d4:	90 e0       	ldi	r25, 0x00	; 0
 3d6:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 3da:	06 c0       	rjmp	.+12     	; 0x3e8 <input_check+0x272>
		   }else if ((in8==2) && (led_status[i]==2)){ // по входу протечка исчезла, начинаем мигать светодиодом
 3dc:	f8 01       	movw	r30, r16
 3de:	80 81       	ld	r24, Z
}

void input_check(void){
// проверяем состояние входов, поднимаем аварию и изменяем состояние светодидов
unsigned int i;	
for (i=0;i<max_in;i++){ // перебираем массив с настройками входов
 3e0:	c8 30       	cpi	r28, 0x08	; 8
 3e2:	d1 05       	cpc	r29, r1
 3e4:	08 f4       	brcc	.+2      	; 0x3e8 <input_check+0x272>
 3e6:	09 cf       	rjmp	.-494    	; 0x1fa <input_check+0x84>
  }
  
 }
}

if (alarm==1){tap_status[0]=1;tap_status[1]=1;gsm_on;} //закрываем краны так как сработал один из входов датчиков протечек
 3e8:	80 91 b2 01 	lds	r24, 0x01B2
 3ec:	81 30       	cpi	r24, 0x01	; 1
 3ee:	49 f4       	brne	.+18     	; 0x402 <input_check+0x28c>
 3f0:	e6 ea       	ldi	r30, 0xA6	; 166
 3f2:	f1 e0       	ldi	r31, 0x01	; 1
 3f4:	81 93       	st	Z+, r24
 3f6:	80 83       	st	Z, r24
 3f8:	e5 e3       	ldi	r30, 0x35	; 53
 3fa:	f0 e0       	ldi	r31, 0x00	; 0
 3fc:	80 81       	ld	r24, Z
 3fe:	82 60       	ori	r24, 0x02	; 2
 400:	80 83       	st	Z, r24
}
 402:	df 91       	pop	r29
 404:	cf 91       	pop	r28
 406:	1f 91       	pop	r17
 408:	0f 91       	pop	r16
 40a:	ff 90       	pop	r15
 40c:	ef 90       	pop	r14
 40e:	df 90       	pop	r13
 410:	cf 90       	pop	r12
 412:	bf 90       	pop	r11
 414:	af 90       	pop	r10
 416:	9f 90       	pop	r9
 418:	8f 90       	pop	r8
 41a:	7f 90       	pop	r7
 41c:	6f 90       	pop	r6
 41e:	5f 90       	pop	r5
 420:	4f 90       	pop	r4
 422:	3f 90       	pop	r3
 424:	2f 90       	pop	r2
 426:	08 95       	ret

00000428 <alarm_reset>:

void alarm_reset(void){
// сбрасываем флаг аварии если бипер отпищал

 if ((beep_count==0) && (alarm==1)){
 428:	80 91 b1 01 	lds	r24, 0x01B1
 42c:	88 23       	and	r24, r24
 42e:	79 f4       	brne	.+30     	; 0x44e <alarm_reset+0x26>
 430:	80 91 b2 01 	lds	r24, 0x01B2
 434:	81 30       	cpi	r24, 0x01	; 1
 436:	59 f4       	brne	.+22     	; 0x44e <alarm_reset+0x26>
  alarm=0; //сбасываем флаг аварии, так как нужные входы замигали
 438:	10 92 b2 01 	sts	0x01B2, r1
  gsm_off; // поднимаем на выходе в GSM сигнализации лог.1 (нет протечки)
 43c:	e5 e3       	ldi	r30, 0x35	; 53
 43e:	f0 e0       	ldi	r31, 0x00	; 0
 440:	80 81       	ld	r24, Z
 442:	8d 7f       	andi	r24, 0xFD	; 253
 444:	80 83       	st	Z, r24
  USART_Send_srt("ALARM AUTO RESET, SPEAKET OFF");
 446:	80 ed       	ldi	r24, 0xD0	; 208
 448:	90 e0       	ldi	r25, 0x00	; 0
 44a:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 44e:	08 95       	ret

00000450 <__vector_9>:
 }
}


SIGNAL(SIG_OVERFLOW0){
 450:	1f 92       	push	r1
 452:	0f 92       	push	r0
 454:	0f b6       	in	r0, 0x3f	; 63
 456:	0f 92       	push	r0
 458:	11 24       	eor	r1, r1
 45a:	2f 93       	push	r18
 45c:	3f 93       	push	r19
 45e:	4f 93       	push	r20
 460:	5f 93       	push	r21
 462:	6f 93       	push	r22
 464:	7f 93       	push	r23
 466:	8f 93       	push	r24
 468:	9f 93       	push	r25
 46a:	af 93       	push	r26
 46c:	bf 93       	push	r27
 46e:	ef 93       	push	r30
 470:	ff 93       	push	r31
// прерывание от таймера0 с частотой 122гц или 0,008192 секунды
static unsigned char beep_flag=0; // флаг для генерации сигнала через бипер

 if (beep_count>0) {
 472:	80 91 b1 01 	lds	r24, 0x01B1
 476:	88 23       	and	r24, r24
 478:	f1 f0       	breq	.+60     	; 0x4b6 <__stack+0x57>
  if (beep_count % 2==0){ // проверяем четное ли значение в beep_count
 47a:	80 91 b1 01 	lds	r24, 0x01B1
 47e:	80 fd       	sbrc	r24, 0
 480:	15 c0       	rjmp	.+42     	; 0x4ac <__stack+0x4d>
   if (beep_flag!=0){ // генерируем на порте сигнал
 482:	80 91 bd 01 	lds	r24, 0x01BD
 486:	88 23       	and	r24, r24
 488:	41 f0       	breq	.+16     	; 0x49a <__stack+0x3b>
    beep_on;
 48a:	e2 e3       	ldi	r30, 0x32	; 50
 48c:	f0 e0       	ldi	r31, 0x00	; 0
 48e:	80 81       	ld	r24, Z
 490:	80 61       	ori	r24, 0x10	; 16
 492:	80 83       	st	Z, r24
    beep_flag=0;
 494:	10 92 bd 01 	sts	0x01BD, r1
 498:	0e c0       	rjmp	.+28     	; 0x4b6 <__stack+0x57>
   }else{
    beep_off;
 49a:	e2 e3       	ldi	r30, 0x32	; 50
 49c:	f0 e0       	ldi	r31, 0x00	; 0
 49e:	80 81       	ld	r24, Z
 4a0:	8f 7e       	andi	r24, 0xEF	; 239
 4a2:	80 83       	st	Z, r24
    beep_flag=1;
 4a4:	81 e0       	ldi	r24, 0x01	; 1
 4a6:	80 93 bd 01 	sts	0x01BD, r24
 4aa:	05 c0       	rjmp	.+10     	; 0x4b6 <__stack+0x57>
   }

  }else{
   beep_off; // нечетное
 4ac:	e2 e3       	ldi	r30, 0x32	; 50
 4ae:	f0 e0       	ldi	r31, 0x00	; 0
 4b0:	80 81       	ld	r24, Z
 4b2:	8f 7e       	andi	r24, 0xEF	; 239
 4b4:	80 83       	st	Z, r24
  }
 }

// накапливаем в счетчиках время нажатия клавиш
if ((reset_botton==0) && (reset_key<long_press+2)) {reset_key++;} // счетчик времени нажатия на кнопку RESET
 4b6:	82 99       	sbic	0x10, 2	; 16
 4b8:	10 c0       	rjmp	.+32     	; 0x4da <__stack+0x7b>
 4ba:	80 91 b4 01 	lds	r24, 0x01B4
 4be:	90 91 b5 01 	lds	r25, 0x01B5
 4c2:	80 57       	subi	r24, 0x70	; 112
 4c4:	91 40       	sbci	r25, 0x01	; 1
 4c6:	48 f4       	brcc	.+18     	; 0x4da <__stack+0x7b>
 4c8:	80 91 b4 01 	lds	r24, 0x01B4
 4cc:	90 91 b5 01 	lds	r25, 0x01B5
 4d0:	01 96       	adiw	r24, 0x01	; 1
 4d2:	90 93 b5 01 	sts	0x01B5, r25
 4d6:	80 93 b4 01 	sts	0x01B4, r24
if ((set_botton==0) && (set_key<long_press+2)) {set_key++;} // счетчик времени нажатия на кнопку SET
 4da:	83 99       	sbic	0x10, 3	; 16
 4dc:	10 c0       	rjmp	.+32     	; 0x4fe <__stack+0x9f>
 4de:	80 91 b6 01 	lds	r24, 0x01B6
 4e2:	90 91 b7 01 	lds	r25, 0x01B7
 4e6:	80 57       	subi	r24, 0x70	; 112
 4e8:	91 40       	sbci	r25, 0x01	; 1
 4ea:	48 f4       	brcc	.+18     	; 0x4fe <__stack+0x9f>
 4ec:	80 91 b6 01 	lds	r24, 0x01B6
 4f0:	90 91 b7 01 	lds	r25, 0x01B7
 4f4:	01 96       	adiw	r24, 0x01	; 1
 4f6:	90 93 b7 01 	sts	0x01B7, r25
 4fa:	80 93 b6 01 	sts	0x01B6, r24
if ((hot_tap_botton==0) && (hot_tap_key<long_press+2)) {hot_tap_key++;} // счетчик времени нажатия на кнопку вкл/выкл горячей воды
 4fe:	80 b3       	in	r24, 0x10	; 16
 500:	88 23       	and	r24, r24
 502:	84 f0       	brlt	.+32     	; 0x524 <__stack+0xc5>
 504:	80 91 b8 01 	lds	r24, 0x01B8
 508:	90 91 b9 01 	lds	r25, 0x01B9
 50c:	80 57       	subi	r24, 0x70	; 112
 50e:	91 40       	sbci	r25, 0x01	; 1
 510:	48 f4       	brcc	.+18     	; 0x524 <__stack+0xc5>
 512:	80 91 b8 01 	lds	r24, 0x01B8
 516:	90 91 b9 01 	lds	r25, 0x01B9
 51a:	01 96       	adiw	r24, 0x01	; 1
 51c:	90 93 b9 01 	sts	0x01B9, r25
 520:	80 93 b8 01 	sts	0x01B8, r24
if ((cold_tap_botton==0) && (cold_tap_key<long_press+2)) {cold_tap_key++;} // счетчик времени нажатия на кнопку вкл/выкл холодной воды
 524:	98 99       	sbic	0x13, 0	; 19
 526:	10 c0       	rjmp	.+32     	; 0x548 <__stack+0xe9>
 528:	80 91 ba 01 	lds	r24, 0x01BA
 52c:	90 91 bb 01 	lds	r25, 0x01BB
 530:	80 57       	subi	r24, 0x70	; 112
 532:	91 40       	sbci	r25, 0x01	; 1
 534:	48 f4       	brcc	.+18     	; 0x548 <__stack+0xe9>
 536:	80 91 ba 01 	lds	r24, 0x01BA
 53a:	90 91 bb 01 	lds	r25, 0x01BB
 53e:	01 96       	adiw	r24, 0x01	; 1
 540:	90 93 bb 01 	sts	0x01BB, r25
 544:	80 93 ba 01 	sts	0x01BA, r24

if ( (botton_ready==0) && (reset_botton==1) && (set_botton==1) && (hot_tap_botton==1) && (cold_tap_botton==1) 
 548:	80 91 bc 01 	lds	r24, 0x01BC
 54c:	88 23       	and	r24, r24
 54e:	41 f5       	brne	.+80     	; 0x5a0 <__stack+0x141>
 550:	82 9b       	sbis	0x10, 2	; 16
 552:	26 c0       	rjmp	.+76     	; 0x5a0 <__stack+0x141>
 554:	83 9b       	sbis	0x10, 3	; 16
 556:	24 c0       	rjmp	.+72     	; 0x5a0 <__stack+0x141>
 558:	80 b3       	in	r24, 0x10	; 16
 55a:	88 23       	and	r24, r24
 55c:	0c f5       	brge	.+66     	; 0x5a0 <__stack+0x141>
 55e:	98 9b       	sbis	0x13, 0	; 19
 560:	1f c0       	rjmp	.+62     	; 0x5a0 <__stack+0x141>
 562:	80 91 b4 01 	lds	r24, 0x01B4
 566:	90 91 b5 01 	lds	r25, 0x01B5
 56a:	89 2b       	or	r24, r25
 56c:	91 f4       	brne	.+36     	; 0x592 <__stack+0x133>
 56e:	80 91 b6 01 	lds	r24, 0x01B6
 572:	90 91 b7 01 	lds	r25, 0x01B7
 576:	89 2b       	or	r24, r25
 578:	61 f4       	brne	.+24     	; 0x592 <__stack+0x133>
 57a:	80 91 b8 01 	lds	r24, 0x01B8
 57e:	90 91 b9 01 	lds	r25, 0x01B9
 582:	89 2b       	or	r24, r25
 584:	31 f4       	brne	.+12     	; 0x592 <__stack+0x133>
 586:	80 91 ba 01 	lds	r24, 0x01BA
 58a:	90 91 bb 01 	lds	r25, 0x01BB
 58e:	89 2b       	or	r24, r25
 590:	39 f0       	breq	.+14     	; 0x5a0 <__stack+0x141>
     && ( (reset_key>0) || (set_key>0) || (hot_tap_key>0) || (cold_tap_key>0) )) {
 // кнопки отпущены и были ранее нажаты
 // выставляем флаг необходимости обработки нажатия кнопок
 botton_ready=1;
 592:	81 e0       	ldi	r24, 0x01	; 1
 594:	80 93 bc 01 	sts	0x01BC, r24
 USART_Send_srt("BOTTON OUT");
 598:	8e ee       	ldi	r24, 0xEE	; 238
 59a:	90 e0       	ldi	r25, 0x00	; 0
 59c:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
}

// переходим к динамической индикации

 PORTC &=~(1<<7);// гасим все столбцы
 5a0:	e5 e3       	ldi	r30, 0x35	; 53
 5a2:	f0 e0       	ldi	r31, 0x00	; 0
 5a4:	80 81       	ld	r24, Z
 5a6:	8f 77       	andi	r24, 0x7F	; 127
 5a8:	80 83       	st	Z, r24
 PORTC &=~(1<<6);// гасим все столбцы
 5aa:	80 81       	ld	r24, Z
 5ac:	8f 7b       	andi	r24, 0xBF	; 191
 5ae:	80 83       	st	Z, r24
 PORTC &=~(1<<5);// гасим все столбцы
 5b0:	80 81       	ld	r24, Z
 5b2:	8f 7d       	andi	r24, 0xDF	; 223
 5b4:	80 83       	st	Z, r24
 if(stolb >= stolb_number) {stolb = 0;} // если перебрали все столбцы, то сбрасываем счетчик столбцов в начало
 5b6:	80 91 b3 01 	lds	r24, 0x01B3
 5ba:	83 30       	cpi	r24, 0x03	; 3
 5bc:	10 f0       	brcs	.+4      	; 0x5c2 <__stack+0x163>
 5be:	10 92 b3 01 	sts	0x01B3, r1
 PORTA = stolbec[stolb]; // выводим в порт состояние строк
 5c2:	80 91 b3 01 	lds	r24, 0x01B3
 5c6:	ee eb       	ldi	r30, 0xBE	; 190
 5c8:	f1 e0       	ldi	r31, 0x01	; 1
 5ca:	e8 0f       	add	r30, r24
 5cc:	f1 1d       	adc	r31, r1
 5ce:	80 81       	ld	r24, Z
 5d0:	8b bb       	out	0x1b, r24	; 27
 ++stolb; // переключаем матрицу на следующий столбец
 5d2:	80 91 b3 01 	lds	r24, 0x01B3
 5d6:	8f 5f       	subi	r24, 0xFF	; 255
 5d8:	80 93 b3 01 	sts	0x01B3, r24
}
 5dc:	ff 91       	pop	r31
 5de:	ef 91       	pop	r30
 5e0:	bf 91       	pop	r27
 5e2:	af 91       	pop	r26
 5e4:	9f 91       	pop	r25
 5e6:	8f 91       	pop	r24
 5e8:	7f 91       	pop	r23
 5ea:	6f 91       	pop	r22
 5ec:	5f 91       	pop	r21
 5ee:	4f 91       	pop	r20
 5f0:	3f 91       	pop	r19
 5f2:	2f 91       	pop	r18
 5f4:	0f 90       	pop	r0
 5f6:	0f be       	out	0x3f, r0	; 63
 5f8:	0f 90       	pop	r0
 5fa:	1f 90       	pop	r1
 5fc:	18 95       	reti

000005fe <__vector_8>:

SIGNAL(SIG_OVERFLOW1){
 5fe:	1f 92       	push	r1
 600:	0f 92       	push	r0
 602:	0f b6       	in	r0, 0x3f	; 63
 604:	0f 92       	push	r0
 606:	11 24       	eor	r1, r1
 608:	8f 93       	push	r24
 60a:	9f 93       	push	r25
// прерывание от таймера1 с частотой 0,12гц или 8,4 секунды
 if (beep_count>0) {
 60c:	80 91 b1 01 	lds	r24, 0x01B1
 610:	88 23       	and	r24, r24
 612:	29 f0       	breq	.+10     	; 0x61e <__vector_8+0x20>
  beep_count--;
 614:	80 91 b1 01 	lds	r24, 0x01B1
 618:	81 50       	subi	r24, 0x01	; 1
 61a:	80 93 b1 01 	sts	0x01B1, r24
 }
TCNT1=65635-7801; // задаем отсчет чтобы вызвать прерывание на частоте 1Гц.
 61e:	8a ee       	ldi	r24, 0xEA	; 234
 620:	91 ee       	ldi	r25, 0xE1	; 225
 622:	9d bd       	out	0x2d, r25	; 45
 624:	8c bd       	out	0x2c, r24	; 44
}
 626:	9f 91       	pop	r25
 628:	8f 91       	pop	r24
 62a:	0f 90       	pop	r0
 62c:	0f be       	out	0x3f, r0	; 63
 62e:	0f 90       	pop	r0
 630:	1f 90       	pop	r1
 632:	18 95       	reti

00000634 <set_leds>:

void set_leds(void){
 634:	2f 92       	push	r2
 636:	3f 92       	push	r3
 638:	4f 92       	push	r4
 63a:	5f 92       	push	r5
 63c:	6f 92       	push	r6
 63e:	7f 92       	push	r7
 640:	8f 92       	push	r8
 642:	9f 92       	push	r9
 644:	af 92       	push	r10
 646:	bf 92       	push	r11
 648:	cf 92       	push	r12
 64a:	df 92       	push	r13
 64c:	ef 92       	push	r14
 64e:	ff 92       	push	r15
 650:	0f 93       	push	r16
 652:	1f 93       	push	r17
 654:	df 93       	push	r29
 656:	cf 93       	push	r28
 658:	cd b7       	in	r28, 0x3d	; 61
 65a:	de b7       	in	r29, 0x3e	; 62
 65c:	27 97       	sbiw	r28, 0x07	; 7
 65e:	0f b6       	in	r0, 0x3f	; 63
 660:	f8 94       	cli
 662:	de bf       	out	0x3e, r29	; 62
 664:	0f be       	out	0x3f, r0	; 63
 666:	cd bf       	out	0x3d, r28	; 61
unsigned int i;	
 for (i=0;i<stolb_number;i++){ // перебираем массив столбцов
  switch(stolb){
   case 0: {PORTC|=(1<<7);
            stolbec[0]=0;
            if (led_status[1]==1) {stolbec[0]|=(1<<0);}
 668:	e9 ea       	ldi	r30, 0xA9	; 169
 66a:	f1 e0       	ldi	r31, 0x01	; 1
 66c:	80 81       	ld	r24, Z
 66e:	8f 83       	std	Y+7, r24	; 0x07
	  	    if (led_status[0]==1) {stolbec[0]|=(1<<1);}
 670:	a2 91       	ld	r26, -Z
 672:	ae 83       	std	Y+6, r26	; 0x06
	 	    if (led_status[7]==1) {stolbec[0]|=(1<<2);}
 674:	b7 81       	ldd	r27, Z+7	; 0x07
 676:	bd 83       	std	Y+5, r27	; 0x05
	 	    if (led_status[6]==1) {stolbec[0]|=(1<<3);}
 678:	86 81       	ldd	r24, Z+6	; 0x06
 67a:	8c 83       	std	Y+4, r24	; 0x04
		    if (led_status[18]==1) {stolbec[0]|=(1<<7);}
		    break;
		   }
   case 1: {PORTC|=(1<<6);
            stolbec[1]=0;
            if (led_status[3]==1) {stolbec[1]|=(1<<0);}
 67c:	a3 81       	ldd	r26, Z+3	; 0x03
 67e:	ab 83       	std	Y+3, r26	; 0x03
		    if (led_status[2]==1) {stolbec[1]|=(1<<1);}
 680:	b2 81       	ldd	r27, Z+2	; 0x02
 682:	ba 83       	std	Y+2, r27	; 0x02
		    if (led_status[20]==1) {stolbec[1]|=(1<<7);}
		    break;
		   }
   case 2: {PORTC|=(1<<5);
            stolbec[2]=0;
            if (led_status[5]==1) {stolbec[2]|=(1<<0);}
 684:	85 81       	ldd	r24, Z+5	; 0x05
 686:	89 83       	std	Y+1, r24	; 0x01
		    if (led_status[4]==1) {stolbec[2]|=(1<<1);}
 688:	94 81       	ldd	r25, Z+4	; 0x04
 68a:	20 e0       	ldi	r18, 0x00	; 0
 68c:	30 e0       	ldi	r19, 0x00	; 0
		    if (led_status[12]==1) {stolbec[0]|=(1<<5);}
		    if (led_status[19]==1) {stolbec[0]|=(1<<6);}
		    if (led_status[18]==1) {stolbec[0]|=(1<<7);}
		    break;
		   }
   case 1: {PORTC|=(1<<6);
 68e:	45 e3       	ldi	r20, 0x35	; 53
 690:	50 e0       	ldi	r21, 0x00	; 0
            stolbec[1]=0;
 692:	af eb       	ldi	r26, 0xBF	; 191
 694:	b1 e0       	ldi	r27, 0x01	; 1
		    if (led_status[2]==1) {stolbec[1]|=(1<<1);}
		    if (led_status[9]==1) {stolbec[1]|=(1<<2);}
		    if (led_status[8]==1) {stolbec[1]|=(1<<3);}
		    if (led_status[15]==1) {stolbec[1]|=(1<<4);}
		    if (led_status[14]==1) {stolbec[1]|=(1<<5);}
		    if (led_status[21]==1) {stolbec[1]|=(1<<6);}
 696:	0f 2e       	mov	r0, r31
 698:	fd eb       	ldi	r31, 0xBD	; 189
 69a:	6f 2e       	mov	r6, r31
 69c:	f1 e0       	ldi	r31, 0x01	; 1
 69e:	7f 2e       	mov	r7, r31
 6a0:	f0 2d       	mov	r31, r0
		    if (led_status[20]==1) {stolbec[1]|=(1<<7);}
 6a2:	0f 2e       	mov	r0, r31
 6a4:	fc eb       	ldi	r31, 0xBC	; 188
 6a6:	4f 2e       	mov	r4, r31
 6a8:	f1 e0       	ldi	r31, 0x01	; 1
 6aa:	5f 2e       	mov	r5, r31
 6ac:	f0 2d       	mov	r31, r0
            stolbec[0]=0;
            if (led_status[1]==1) {stolbec[0]|=(1<<0);}
	  	    if (led_status[0]==1) {stolbec[0]|=(1<<1);}
	 	    if (led_status[7]==1) {stolbec[0]|=(1<<2);}
	 	    if (led_status[6]==1) {stolbec[0]|=(1<<3);}
		    if (led_status[13]==1) {stolbec[0]|=(1<<4);}
 6ae:	0f 2e       	mov	r0, r31
 6b0:	f5 eb       	ldi	r31, 0xB5	; 181
 6b2:	2f 2e       	mov	r2, r31
 6b4:	f1 e0       	ldi	r31, 0x01	; 1
 6b6:	3f 2e       	mov	r3, r31
 6b8:	f0 2d       	mov	r31, r0
		    if (led_status[12]==1) {stolbec[0]|=(1<<5);}
		    if (led_status[19]==1) {stolbec[0]|=(1<<6);}
 6ba:	0b eb       	ldi	r16, 0xBB	; 187
 6bc:	11 e0       	ldi	r17, 0x01	; 1
		    if (led_status[18]==1) {stolbec[0]|=(1<<7);}
 6be:	0f 2e       	mov	r0, r31
 6c0:	fa eb       	ldi	r31, 0xBA	; 186
 6c2:	ef 2e       	mov	r14, r31
 6c4:	f1 e0       	ldi	r31, 0x01	; 1
 6c6:	ff 2e       	mov	r15, r31
 6c8:	f0 2d       	mov	r31, r0
		   }
   case 2: {PORTC|=(1<<5);
            stolbec[2]=0;
            if (led_status[5]==1) {stolbec[2]|=(1<<0);}
		    if (led_status[4]==1) {stolbec[2]|=(1<<1);}
		    if (led_status[11]==1) {stolbec[2]|=(1<<2);}
 6ca:	0f 2e       	mov	r0, r31
 6cc:	f3 eb       	ldi	r31, 0xB3	; 179
 6ce:	cf 2e       	mov	r12, r31
 6d0:	f1 e0       	ldi	r31, 0x01	; 1
 6d2:	df 2e       	mov	r13, r31
 6d4:	f0 2d       	mov	r31, r0
		    if (led_status[10]==1) {stolbec[2]|=(1<<3);}
 6d6:	0f 2e       	mov	r0, r31
 6d8:	f2 eb       	ldi	r31, 0xB2	; 178
 6da:	af 2e       	mov	r10, r31
 6dc:	f1 e0       	ldi	r31, 0x01	; 1
 6de:	bf 2e       	mov	r11, r31
 6e0:	f0 2d       	mov	r31, r0
		    if (led_status[17]==1) {stolbec[2]|=(1<<4);}
 6e2:	0f 2e       	mov	r0, r31
 6e4:	f9 eb       	ldi	r31, 0xB9	; 185
 6e6:	8f 2e       	mov	r8, r31
 6e8:	f1 e0       	ldi	r31, 0x01	; 1
 6ea:	9f 2e       	mov	r9, r31
 6ec:	f0 2d       	mov	r31, r0
		    if (led_status[16]==1) {stolbec[2]|=(1<<5);}
 6ee:	68 eb       	ldi	r22, 0xB8	; 184
 6f0:	71 e0       	ldi	r23, 0x01	; 1

void set_leds(void){
// устанавливаем массив для отображения в матрице светодиодов в значения из массива состояния светодидодов (мэппинг)
unsigned int i;	
 for (i=0;i<stolb_number;i++){ // перебираем массив столбцов
  switch(stolb){
 6f2:	80 91 b3 01 	lds	r24, 0x01B3
 6f6:	81 30       	cpi	r24, 0x01	; 1
 6f8:	09 f4       	brne	.+2      	; 0x6fc <set_leds+0xc8>
 6fa:	54 c0       	rjmp	.+168    	; 0x7a4 <set_leds+0x170>
 6fc:	81 30       	cpi	r24, 0x01	; 1
 6fe:	20 f0       	brcs	.+8      	; 0x708 <set_leds+0xd4>
 700:	82 30       	cpi	r24, 0x02	; 2
 702:	09 f0       	breq	.+2      	; 0x706 <set_leds+0xd2>
 704:	c9 c0       	rjmp	.+402    	; 0x898 <set_leds+0x264>
 706:	8e c0       	rjmp	.+284    	; 0x824 <set_leds+0x1f0>
   case 0: {PORTC|=(1<<7);
 708:	fa 01       	movw	r30, r20
 70a:	80 81       	ld	r24, Z
 70c:	80 68       	ori	r24, 0x80	; 128
 70e:	80 83       	st	Z, r24
            stolbec[0]=0;
 710:	ee eb       	ldi	r30, 0xBE	; 190
 712:	f1 e0       	ldi	r31, 0x01	; 1
 714:	10 82       	st	Z, r1
            if (led_status[1]==1) {stolbec[0]|=(1<<0);}
 716:	ff 81       	ldd	r31, Y+7	; 0x07
 718:	f1 30       	cpi	r31, 0x01	; 1
 71a:	29 f4       	brne	.+10     	; 0x726 <set_leds+0xf2>
 71c:	ee eb       	ldi	r30, 0xBE	; 190
 71e:	f1 e0       	ldi	r31, 0x01	; 1
 720:	80 81       	ld	r24, Z
 722:	81 60       	ori	r24, 0x01	; 1
 724:	80 83       	st	Z, r24
	  	    if (led_status[0]==1) {stolbec[0]|=(1<<1);}
 726:	fe 81       	ldd	r31, Y+6	; 0x06
 728:	f1 30       	cpi	r31, 0x01	; 1
 72a:	29 f4       	brne	.+10     	; 0x736 <set_leds+0x102>
 72c:	ee eb       	ldi	r30, 0xBE	; 190
 72e:	f1 e0       	ldi	r31, 0x01	; 1
 730:	80 81       	ld	r24, Z
 732:	82 60       	ori	r24, 0x02	; 2
 734:	80 83       	st	Z, r24
	 	    if (led_status[7]==1) {stolbec[0]|=(1<<2);}
 736:	fd 81       	ldd	r31, Y+5	; 0x05
 738:	f1 30       	cpi	r31, 0x01	; 1
 73a:	29 f4       	brne	.+10     	; 0x746 <set_leds+0x112>
 73c:	ee eb       	ldi	r30, 0xBE	; 190
 73e:	f1 e0       	ldi	r31, 0x01	; 1
 740:	80 81       	ld	r24, Z
 742:	84 60       	ori	r24, 0x04	; 4
 744:	80 83       	st	Z, r24
	 	    if (led_status[6]==1) {stolbec[0]|=(1<<3);}
 746:	fc 81       	ldd	r31, Y+4	; 0x04
 748:	f1 30       	cpi	r31, 0x01	; 1
 74a:	29 f4       	brne	.+10     	; 0x756 <set_leds+0x122>
 74c:	ee eb       	ldi	r30, 0xBE	; 190
 74e:	f1 e0       	ldi	r31, 0x01	; 1
 750:	80 81       	ld	r24, Z
 752:	88 60       	ori	r24, 0x08	; 8
 754:	80 83       	st	Z, r24
		    if (led_status[13]==1) {stolbec[0]|=(1<<4);}
 756:	f1 01       	movw	r30, r2
 758:	80 81       	ld	r24, Z
 75a:	81 30       	cpi	r24, 0x01	; 1
 75c:	29 f4       	brne	.+10     	; 0x768 <set_leds+0x134>
 75e:	ee eb       	ldi	r30, 0xBE	; 190
 760:	f1 e0       	ldi	r31, 0x01	; 1
 762:	80 81       	ld	r24, Z
 764:	80 61       	ori	r24, 0x10	; 16
 766:	80 83       	st	Z, r24
		    if (led_status[12]==1) {stolbec[0]|=(1<<5);}
 768:	e4 eb       	ldi	r30, 0xB4	; 180
 76a:	f1 e0       	ldi	r31, 0x01	; 1
 76c:	80 81       	ld	r24, Z
 76e:	81 30       	cpi	r24, 0x01	; 1
 770:	29 f4       	brne	.+10     	; 0x77c <set_leds+0x148>
 772:	ee eb       	ldi	r30, 0xBE	; 190
 774:	f1 e0       	ldi	r31, 0x01	; 1
 776:	80 81       	ld	r24, Z
 778:	80 62       	ori	r24, 0x20	; 32
 77a:	80 83       	st	Z, r24
		    if (led_status[19]==1) {stolbec[0]|=(1<<6);}
 77c:	f8 01       	movw	r30, r16
 77e:	80 81       	ld	r24, Z
 780:	81 30       	cpi	r24, 0x01	; 1
 782:	29 f4       	brne	.+10     	; 0x78e <set_leds+0x15a>
 784:	ee eb       	ldi	r30, 0xBE	; 190
 786:	f1 e0       	ldi	r31, 0x01	; 1
 788:	80 81       	ld	r24, Z
 78a:	80 64       	ori	r24, 0x40	; 64
 78c:	80 83       	st	Z, r24
		    if (led_status[18]==1) {stolbec[0]|=(1<<7);}
 78e:	f7 01       	movw	r30, r14
 790:	80 81       	ld	r24, Z
 792:	81 30       	cpi	r24, 0x01	; 1
 794:	09 f0       	breq	.+2      	; 0x798 <set_leds+0x164>
 796:	80 c0       	rjmp	.+256    	; 0x898 <set_leds+0x264>
 798:	ee eb       	ldi	r30, 0xBE	; 190
 79a:	f1 e0       	ldi	r31, 0x01	; 1
 79c:	80 81       	ld	r24, Z
 79e:	80 68       	ori	r24, 0x80	; 128
 7a0:	80 83       	st	Z, r24
 7a2:	7a c0       	rjmp	.+244    	; 0x898 <set_leds+0x264>
		    break;
		   }
   case 1: {PORTC|=(1<<6);
 7a4:	fa 01       	movw	r30, r20
 7a6:	80 81       	ld	r24, Z
 7a8:	80 64       	ori	r24, 0x40	; 64
 7aa:	80 83       	st	Z, r24
            stolbec[1]=0;
 7ac:	1c 92       	st	X, r1
            if (led_status[3]==1) {stolbec[1]|=(1<<0);}
 7ae:	fb 81       	ldd	r31, Y+3	; 0x03
 7b0:	f1 30       	cpi	r31, 0x01	; 1
 7b2:	19 f4       	brne	.+6      	; 0x7ba <set_leds+0x186>
 7b4:	8c 91       	ld	r24, X
 7b6:	81 60       	ori	r24, 0x01	; 1
 7b8:	8c 93       	st	X, r24
		    if (led_status[2]==1) {stolbec[1]|=(1<<1);}
 7ba:	8a 81       	ldd	r24, Y+2	; 0x02
 7bc:	81 30       	cpi	r24, 0x01	; 1
 7be:	19 f4       	brne	.+6      	; 0x7c6 <set_leds+0x192>
 7c0:	8c 91       	ld	r24, X
 7c2:	82 60       	ori	r24, 0x02	; 2
 7c4:	8c 93       	st	X, r24
		    if (led_status[9]==1) {stolbec[1]|=(1<<2);}
 7c6:	e1 eb       	ldi	r30, 0xB1	; 177
 7c8:	f1 e0       	ldi	r31, 0x01	; 1
 7ca:	80 81       	ld	r24, Z
 7cc:	81 30       	cpi	r24, 0x01	; 1
 7ce:	19 f4       	brne	.+6      	; 0x7d6 <set_leds+0x1a2>
 7d0:	8c 91       	ld	r24, X
 7d2:	84 60       	ori	r24, 0x04	; 4
 7d4:	8c 93       	st	X, r24
		    if (led_status[8]==1) {stolbec[1]|=(1<<3);}
 7d6:	e0 eb       	ldi	r30, 0xB0	; 176
 7d8:	f1 e0       	ldi	r31, 0x01	; 1
 7da:	80 81       	ld	r24, Z
 7dc:	81 30       	cpi	r24, 0x01	; 1
 7de:	19 f4       	brne	.+6      	; 0x7e6 <set_leds+0x1b2>
 7e0:	8c 91       	ld	r24, X
 7e2:	88 60       	ori	r24, 0x08	; 8
 7e4:	8c 93       	st	X, r24
		    if (led_status[15]==1) {stolbec[1]|=(1<<4);}
 7e6:	e7 eb       	ldi	r30, 0xB7	; 183
 7e8:	f1 e0       	ldi	r31, 0x01	; 1
 7ea:	80 81       	ld	r24, Z
 7ec:	81 30       	cpi	r24, 0x01	; 1
 7ee:	19 f4       	brne	.+6      	; 0x7f6 <set_leds+0x1c2>
 7f0:	8c 91       	ld	r24, X
 7f2:	80 61       	ori	r24, 0x10	; 16
 7f4:	8c 93       	st	X, r24
		    if (led_status[14]==1) {stolbec[1]|=(1<<5);}
 7f6:	e6 eb       	ldi	r30, 0xB6	; 182
 7f8:	f1 e0       	ldi	r31, 0x01	; 1
 7fa:	80 81       	ld	r24, Z
 7fc:	81 30       	cpi	r24, 0x01	; 1
 7fe:	19 f4       	brne	.+6      	; 0x806 <set_leds+0x1d2>
 800:	8c 91       	ld	r24, X
 802:	80 62       	ori	r24, 0x20	; 32
 804:	8c 93       	st	X, r24
		    if (led_status[21]==1) {stolbec[1]|=(1<<6);}
 806:	f3 01       	movw	r30, r6
 808:	80 81       	ld	r24, Z
 80a:	81 30       	cpi	r24, 0x01	; 1
 80c:	19 f4       	brne	.+6      	; 0x814 <set_leds+0x1e0>
 80e:	8c 91       	ld	r24, X
 810:	80 64       	ori	r24, 0x40	; 64
 812:	8c 93       	st	X, r24
		    if (led_status[20]==1) {stolbec[1]|=(1<<7);}
 814:	f2 01       	movw	r30, r4
 816:	80 81       	ld	r24, Z
 818:	81 30       	cpi	r24, 0x01	; 1
 81a:	f1 f5       	brne	.+124    	; 0x898 <set_leds+0x264>
 81c:	8c 91       	ld	r24, X
 81e:	80 68       	ori	r24, 0x80	; 128
 820:	8c 93       	st	X, r24
 822:	3a c0       	rjmp	.+116    	; 0x898 <set_leds+0x264>
		    break;
		   }
   case 2: {PORTC|=(1<<5);
 824:	fa 01       	movw	r30, r20
 826:	80 81       	ld	r24, Z
 828:	80 62       	ori	r24, 0x20	; 32
 82a:	80 83       	st	Z, r24
            stolbec[2]=0;
 82c:	e0 ec       	ldi	r30, 0xC0	; 192
 82e:	f1 e0       	ldi	r31, 0x01	; 1
 830:	10 82       	st	Z, r1
            if (led_status[5]==1) {stolbec[2]|=(1<<0);}
 832:	f9 81       	ldd	r31, Y+1	; 0x01
 834:	f1 30       	cpi	r31, 0x01	; 1
 836:	29 f4       	brne	.+10     	; 0x842 <set_leds+0x20e>
 838:	e0 ec       	ldi	r30, 0xC0	; 192
 83a:	f1 e0       	ldi	r31, 0x01	; 1
 83c:	80 81       	ld	r24, Z
 83e:	81 60       	ori	r24, 0x01	; 1
 840:	80 83       	st	Z, r24
		    if (led_status[4]==1) {stolbec[2]|=(1<<1);}
 842:	91 30       	cpi	r25, 0x01	; 1
 844:	29 f4       	brne	.+10     	; 0x850 <set_leds+0x21c>
 846:	e0 ec       	ldi	r30, 0xC0	; 192
 848:	f1 e0       	ldi	r31, 0x01	; 1
 84a:	80 81       	ld	r24, Z
 84c:	82 60       	ori	r24, 0x02	; 2
 84e:	80 83       	st	Z, r24
		    if (led_status[11]==1) {stolbec[2]|=(1<<2);}
 850:	f6 01       	movw	r30, r12
 852:	80 81       	ld	r24, Z
 854:	81 30       	cpi	r24, 0x01	; 1
 856:	29 f4       	brne	.+10     	; 0x862 <set_leds+0x22e>
 858:	e0 ec       	ldi	r30, 0xC0	; 192
 85a:	f1 e0       	ldi	r31, 0x01	; 1
 85c:	80 81       	ld	r24, Z
 85e:	84 60       	ori	r24, 0x04	; 4
 860:	80 83       	st	Z, r24
		    if (led_status[10]==1) {stolbec[2]|=(1<<3);}
 862:	f5 01       	movw	r30, r10
 864:	80 81       	ld	r24, Z
 866:	81 30       	cpi	r24, 0x01	; 1
 868:	29 f4       	brne	.+10     	; 0x874 <set_leds+0x240>
 86a:	e0 ec       	ldi	r30, 0xC0	; 192
 86c:	f1 e0       	ldi	r31, 0x01	; 1
 86e:	80 81       	ld	r24, Z
 870:	88 60       	ori	r24, 0x08	; 8
 872:	80 83       	st	Z, r24
		    if (led_status[17]==1) {stolbec[2]|=(1<<4);}
 874:	f4 01       	movw	r30, r8
 876:	80 81       	ld	r24, Z
 878:	81 30       	cpi	r24, 0x01	; 1
 87a:	29 f4       	brne	.+10     	; 0x886 <set_leds+0x252>
 87c:	e0 ec       	ldi	r30, 0xC0	; 192
 87e:	f1 e0       	ldi	r31, 0x01	; 1
 880:	80 81       	ld	r24, Z
 882:	80 61       	ori	r24, 0x10	; 16
 884:	80 83       	st	Z, r24
		    if (led_status[16]==1) {stolbec[2]|=(1<<5);}
 886:	fb 01       	movw	r30, r22
 888:	80 81       	ld	r24, Z
 88a:	81 30       	cpi	r24, 0x01	; 1
 88c:	29 f4       	brne	.+10     	; 0x898 <set_leds+0x264>
 88e:	e0 ec       	ldi	r30, 0xC0	; 192
 890:	f1 e0       	ldi	r31, 0x01	; 1
 892:	80 81       	ld	r24, Z
 894:	80 62       	ori	r24, 0x20	; 32
 896:	80 83       	st	Z, r24
}

void set_leds(void){
// устанавливаем массив для отображения в матрице светодиодов в значения из массива состояния светодидодов (мэппинг)
unsigned int i;	
 for (i=0;i<stolb_number;i++){ // перебираем массив столбцов
 898:	2f 5f       	subi	r18, 0xFF	; 255
 89a:	3f 4f       	sbci	r19, 0xFF	; 255
 89c:	23 30       	cpi	r18, 0x03	; 3
 89e:	31 05       	cpc	r19, r1
 8a0:	09 f0       	breq	.+2      	; 0x8a4 <set_leds+0x270>
 8a2:	27 cf       	rjmp	.-434    	; 0x6f2 <set_leds+0xbe>
		    // if (led_status[20]==1) {stolbec[1]|=(1<<7);} // эти светодиоды не подключены
            break;
		   }
  }
 }
}
 8a4:	27 96       	adiw	r28, 0x07	; 7
 8a6:	0f b6       	in	r0, 0x3f	; 63
 8a8:	f8 94       	cli
 8aa:	de bf       	out	0x3e, r29	; 62
 8ac:	0f be       	out	0x3f, r0	; 63
 8ae:	cd bf       	out	0x3d, r28	; 61
 8b0:	cf 91       	pop	r28
 8b2:	df 91       	pop	r29
 8b4:	1f 91       	pop	r17
 8b6:	0f 91       	pop	r16
 8b8:	ff 90       	pop	r15
 8ba:	ef 90       	pop	r14
 8bc:	df 90       	pop	r13
 8be:	cf 90       	pop	r12
 8c0:	bf 90       	pop	r11
 8c2:	af 90       	pop	r10
 8c4:	9f 90       	pop	r9
 8c6:	8f 90       	pop	r8
 8c8:	7f 90       	pop	r7
 8ca:	6f 90       	pop	r6
 8cc:	5f 90       	pop	r5
 8ce:	4f 90       	pop	r4
 8d0:	3f 90       	pop	r3
 8d2:	2f 90       	pop	r2
 8d4:	08 95       	ret

000008d6 <main_init>:

}

void main_init(void){
// настраиваем порты(ножки)
DDRB=0b00000000; //делаем входами все порты PINB.
 8d6:	17 ba       	out	0x17, r1	; 23
PINB=0b00000000; //выводим на все входы PORTB 0, кроме 0
 8d8:	16 ba       	out	0x16, r1	; 22
PORTB=0b00000000; // и подягиваем на +питания.
 8da:	18 ba       	out	0x18, r1	; 24

DDRA=0b11111111; //делаем выходами все порты PINA.
 8dc:	8f ef       	ldi	r24, 0xFF	; 255
 8de:	8a bb       	out	0x1a, r24	; 26
PINA=0b00000000; //выводим на все выходы PORTA 0
 8e0:	19 ba       	out	0x19, r1	; 25
PORTA=0b00000000; // и подягиваем на +питания.
 8e2:	1b ba       	out	0x1b, r1	; 27

DDRD=0b01110000; //делаем входами с PIND0 по PIND3 и PIND7, с PIND4 по PIND6 делаем выходами.
 8e4:	80 e7       	ldi	r24, 0x70	; 112
 8e6:	81 bb       	out	0x11, r24	; 17
PIND=0b00000000; //выводим на все выходы PORTD 0
 8e8:	10 ba       	out	0x10, r1	; 16
PORTD=0b00000000; // и подягиваем на +питания.
 8ea:	12 ba       	out	0x12, r1	; 18


DDRC=0b11111110; //делаем выходами все порты PINC, кроме PINC0
 8ec:	8e ef       	ldi	r24, 0xFE	; 254
 8ee:	84 bb       	out	0x14, r24	; 20
PINC=0b00000000; //выводим на все выходы PORTC 0
 8f0:	13 ba       	out	0x13, r1	; 19
PORTC=0b00000000; // и подягиваем на +питания.
 8f2:	15 ba       	out	0x15, r1	; 21
// WDTCR=(1<<WDE); //Watchdog Enable
// WDTCR=|(1<<WDP2)|(1<<WDP1)|(0<<WDP0); //Watchdog Timer Prescale Select=1.0 s
// WDTCR = 0x00; /* Turn off WDT */

// настраиваем таймер0 для динамической индикации
TIMSK=(1<<TOIE0); // Timer/Counter0 Overflow Interrupt Enable
 8f4:	e9 e5       	ldi	r30, 0x59	; 89
 8f6:	f0 e0       	ldi	r31, 0x00	; 0
 8f8:	81 e0       	ldi	r24, 0x01	; 1
 8fa:	80 83       	st	Z, r24
TCCR0=(1<<CS02); // Clock Select Bit Description=clkI/O/256 (From prescaler)
 8fc:	84 e0       	ldi	r24, 0x04	; 4
 8fe:	83 bf       	out	0x33, r24	; 51

// настраиваем таймер1 для отсчета месяца и длительности бипера
TIMSK|=(1<<TOIE1); // Timer/Counter1, Overflow Interrupt Enable
 900:	80 81       	ld	r24, Z
 902:	84 60       	ori	r24, 0x04	; 4
 904:	80 83       	st	Z, r24
TCCR1B=(1<<CS12)|(0<<CS11)|(1<<CS10); // clkI/O/1024 (From prescaler)
 906:	85 e0       	ldi	r24, 0x05	; 5
 908:	8e bd       	out	0x2e, r24	; 46
TCNT1=65635-7801; // задаем отсчет чтобы вызвать прерывание на частоте 1Гц.
 90a:	8a ee       	ldi	r24, 0xEA	; 234
 90c:	91 ee       	ldi	r25, 0xE1	; 225
 90e:	9d bd       	out	0x2d, r25	; 45
 910:	8c bd       	out	0x2c, r24	; 44

//настраиваем UART
USART_Init(9600);
 912:	80 e8       	ldi	r24, 0x80	; 128
 914:	95 e2       	ldi	r25, 0x25	; 37
 916:	0e 94 49 00 	call	0x92	; 0x92 <USART_Init>
//настроили UART

USART_Send_srt("START");
 91a:	89 ef       	ldi	r24, 0xF9	; 249
 91c:	90 e0       	ldi	r25, 0x00	; 0
 91e:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>

sei(); // разрешаем прерывания глобально
 922:	78 94       	sei
}
 924:	08 95       	ret

00000926 <__vector_1>:

/****************** ЛОВИМ ПРЕРЫВАНИЕ НА INT0 ПО НИЗКОМУ ПОТЕНЦИАЛУ (ДЛЯ ВЫХОДА ИЗ POWER-DOWN) ********************/
SIGNAL(INT0_vect){
 926:	1f 92       	push	r1
 928:	0f 92       	push	r0
 92a:	0f b6       	in	r0, 0x3f	; 63
 92c:	0f 92       	push	r0
 92e:	11 24       	eor	r1, r1
}
 930:	0f 90       	pop	r0
 932:	0f be       	out	0x3f, r0	; 63
 934:	0f 90       	pop	r0
 936:	1f 90       	pop	r1
 938:	18 95       	reti

0000093a <go_sleep>:

void go_sleep(void){
 // вгоняем МК в POWER-DOWN
 USART_Send_srt("SLEEP ON");
 93a:	8f ef       	ldi	r24, 0xFF	; 255
 93c:	90 e0       	ldi	r25, 0x00	; 0
 93e:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 TCCR0=0; // выключаем таймер0
 942:	13 be       	out	0x33, r1	; 51
 TCCR1B =0; // выключаем таймер1
 944:	1e bc       	out	0x2e, r1	; 46
 cli(); // зарещаем прерывания глобально
 946:	f8 94       	cli
 GICR|=(1<<INT0); // External Interrupt Request 0 Enable
 948:	eb e5       	ldi	r30, 0x5B	; 91
 94a:	f0 e0       	ldi	r31, 0x00	; 0
 94c:	80 81       	ld	r24, Z
 94e:	80 64       	ori	r24, 0x40	; 64
 950:	80 83       	st	Z, r24
 GIFR|=(1<<INTF0); // External Interrupt Flag 0
 952:	ea e5       	ldi	r30, 0x5A	; 90
 954:	f0 e0       	ldi	r31, 0x00	; 0
 956:	80 81       	ld	r24, Z
 958:	80 64       	ori	r24, 0x40	; 64
 95a:	80 83       	st	Z, r24
 DDRA=0b00000000; //делаем входами все порты PINA
 95c:	1a ba       	out	0x1a, r1	; 26
 PINA=0b00000000; //выводим на все входы PORTA 0
 95e:	19 ba       	out	0x19, r1	; 25
 DDRB=0b00000000; //делаем входами все порты PINB
 960:	17 ba       	out	0x17, r1	; 23
 PINB=0b00000000; //выводим на все входы PORTB 0
 962:	16 ba       	out	0x16, r1	; 22
 DDRC=0b00000000; //делаем входами все порты PINC
 964:	14 ba       	out	0x14, r1	; 20
 PINC=0b00000000; //выводим на все входы PORTC 0
 966:	13 ba       	out	0x13, r1	; 19
 DDRD=0b00000000; //делаем входами все порты PIND
 968:	11 ba       	out	0x11, r1	; 17
 PIND=0b00000000; //выводим на все входы PORTD 0
 96a:	10 ba       	out	0x10, r1	; 16
 //_delay_ms(100);
 set_sleep_mode(SLEEP_MODE_PWR_DOWN);
 96c:	e5 e5       	ldi	r30, 0x55	; 85
 96e:	f0 e0       	ldi	r31, 0x00	; 0
 970:	80 81       	ld	r24, Z
 972:	8f 74       	andi	r24, 0x4F	; 79
 974:	80 62       	ori	r24, 0x20	; 32
 976:	80 83       	st	Z, r24
 sei(); // разрешаем прерывания глобально
 978:	78 94       	sei
 sleep_mode();
 97a:	e5 e5       	ldi	r30, 0x55	; 85
 97c:	f0 e0       	ldi	r31, 0x00	; 0
 97e:	80 81       	ld	r24, Z
 980:	80 64       	ori	r24, 0x40	; 64
 982:	80 83       	st	Z, r24
 984:	88 95       	sleep
 986:	e5 e5       	ldi	r30, 0x55	; 85
 988:	f0 e0       	ldi	r31, 0x00	; 0
 98a:	80 81       	ld	r24, Z
 98c:	8f 7b       	andi	r24, 0xBF	; 191
 98e:	80 83       	st	Z, r24
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
 990:	80 e4       	ldi	r24, 0x40	; 64
 992:	9c e9       	ldi	r25, 0x9C	; 156
 994:	01 97       	sbiw	r24, 0x01	; 1
 996:	f1 f7       	brne	.-4      	; 0x994 <go_sleep+0x5a>
 _delay_ms(20);
 //cli(); // зарещаем прерывания глобально
 GICR=0;  //Disable Pin Change Interrupt
 998:	1b be       	out	0x3b, r1	; 59
 GIFR=0;
 99a:	1a be       	out	0x3a, r1	; 58
 main_init();
 99c:	0e 94 6b 04 	call	0x8d6	; 0x8d6 <main_init>
 USART_Send_srt("SLEEP OFF");
 9a0:	88 e0       	ldi	r24, 0x08	; 8
 9a2:	91 e0       	ldi	r25, 0x01	; 1
 9a4:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
}
 9a8:	08 95       	ret

000009aa <save_eeprom_data>:
            break;
		   }
  }
 }
}
void save_eeprom_data(unsigned int eeprom_cell,unsigned int data){
 9aa:	9c 01       	movw	r18, r24
//  сохраняем в EEPROM значение data в ячейку eeprom_cell
 while (eeprom_is_ready()!=1){};
 9ac:	ec e3       	ldi	r30, 0x3C	; 60
 9ae:	f0 e0       	ldi	r31, 0x00	; 0
 9b0:	80 81       	ld	r24, Z
 9b2:	81 fd       	sbrc	r24, 1
 9b4:	fd cf       	rjmp	.-6      	; 0x9b0 <save_eeprom_data+0x6>
  eeprom_write_byte((uint8_t*)eeprom_cell,data); // сохраняем в EEPROM
 9b6:	c9 01       	movw	r24, r18
 9b8:	0e 94 9d 06 	call	0xd3a	; 0xd3a <__eewr_byte_m16>
}
 9bc:	08 95       	ret

000009be <clean_and_reset>:
 GIFR=0;
 main_init();
 USART_Send_srt("SLEEP OFF");
}

void clean_and_reset(void){
 9be:	cf 93       	push	r28
 9c0:	df 93       	push	r29
unsigned int i;	
USART_Send_srt("clean_and_reset");
 9c2:	82 e1       	ldi	r24, 0x12	; 18
 9c4:	91 e0       	ldi	r25, 0x01	; 1
 9c6:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 9ca:	c9 e0       	ldi	r28, 0x09	; 9
 9cc:	d0 e0       	ldi	r29, 0x00	; 0
 for (i=9;i<22;i++){ //очищаем eeprom
  save_eeprom_data(i,0xFF);
 9ce:	ce 01       	movw	r24, r28
 9d0:	6f ef       	ldi	r22, 0xFF	; 255
 9d2:	70 e0       	ldi	r23, 0x00	; 0
 9d4:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
}

void clean_and_reset(void){
unsigned int i;	
USART_Send_srt("clean_and_reset");
 for (i=9;i<22;i++){ //очищаем eeprom
 9d8:	21 96       	adiw	r28, 0x01	; 1
 9da:	c6 31       	cpi	r28, 0x16	; 22
 9dc:	d1 05       	cpc	r29, r1
 9de:	b9 f7       	brne	.-18     	; 0x9ce <clean_and_reset+0x10>
  save_eeprom_data(i,0xFF);
 }

// включаем WD
wdt_enable(WDTO_15MS);
 9e0:	28 e0       	ldi	r18, 0x08	; 8
 9e2:	88 e1       	ldi	r24, 0x18	; 24
 9e4:	90 e0       	ldi	r25, 0x00	; 0
 9e6:	0f b6       	in	r0, 0x3f	; 63
 9e8:	f8 94       	cli
 9ea:	a8 95       	wdr
 9ec:	81 bd       	out	0x21, r24	; 33
 9ee:	0f be       	out	0x3f, r0	; 63
 9f0:	21 bd       	out	0x21, r18	; 33
 9f2:	20 e1       	ldi	r18, 0x10	; 16
 9f4:	37 e2       	ldi	r19, 0x27	; 39
 9f6:	48 ec       	ldi	r20, 0xC8	; 200
 9f8:	50 e0       	ldi	r21, 0x00	; 0
 9fa:	ca 01       	movw	r24, r20
 9fc:	01 97       	sbiw	r24, 0x01	; 1
 9fe:	f1 f7       	brne	.-4      	; 0x9fc <clean_and_reset+0x3e>
		__ticks = (uint16_t) (__ms * 10.0);
		while(__ticks)
		{
			// wait 1/10 ms
			_delay_loop_2(((F_CPU) / 4e3) / 10);
			__ticks --;
 a00:	21 50       	subi	r18, 0x01	; 1
 a02:	30 40       	sbci	r19, 0x00	; 0
		__ticks = 1;
	else if (__tmp > 65535)
	{
		//	__ticks = requested delay in 1/10 ms
		__ticks = (uint16_t) (__ms * 10.0);
		while(__ticks)
 a04:	d1 f7       	brne	.-12     	; 0x9fa <clean_and_reset+0x3c>

// ждем сброса
_delay_ms(1000);
}
 a06:	df 91       	pop	r29
 a08:	cf 91       	pop	r28
 a0a:	08 95       	ret

00000a0c <save_settings>:
// "1"- вход включен (мониторится).
// Если при этом на входе сработал датчик протечки или просто к входу не подключен датчик, то такой вход исключается из мониторинга: 
//  Если при нажатии кнопки SET вход имел высокий логический уровень (+12в) то считается что этот вход нужно мониторить, 
//  светодиод такого входа будет гореть зеленым. Если на входе был низкий уровень, то такой вход исключается из мониторинга и светодиод входа гаснет.

USART_Send_srt("save_settings");
 a0c:	82 e2       	ldi	r24, 0x22	; 34
 a0e:	91 e0       	ldi	r25, 0x01	; 1
 a10:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>

while (eeprom_is_ready()!=1){};
 a14:	ec e3       	ldi	r30, 0x3C	; 60
 a16:	f0 e0       	ldi	r31, 0x00	; 0
 a18:	80 81       	ld	r24, Z
 a1a:	81 fd       	sbrc	r24, 1
 a1c:	fd cf       	rjmp	.-6      	; 0xa18 <save_settings+0xc>
eeprom_write_byte((uint8_t*)9,1); // сохраняем в EEPROM флаг сохраненных настроек
 a1e:	89 e0       	ldi	r24, 0x09	; 9
 a20:	90 e0       	ldi	r25, 0x00	; 0
 a22:	61 e0       	ldi	r22, 0x01	; 1
 a24:	0e 94 9d 06 	call	0xd3a	; 0xd3a <__eewr_byte_m16>

if (in1==1) { // датчик по входу1 подключен и не сработал
 a28:	b0 9b       	sbis	0x16, 0	; 22
 a2a:	07 c0       	rjmp	.+14     	; 0xa3a <save_settings+0x2e>
 save_eeprom_data(10,1); // сохраняем в EEPROM состояние мониторинга входа1
 a2c:	8a e0       	ldi	r24, 0x0A	; 10
 a2e:	90 e0       	ldi	r25, 0x00	; 0
 a30:	61 e0       	ldi	r22, 0x01	; 1
 a32:	70 e0       	ldi	r23, 0x00	; 0
 a34:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
 a38:	06 c0       	rjmp	.+12     	; 0xa46 <save_settings+0x3a>
} else {
 save_eeprom_data(10,0); // сохраняем в EEPROM состояние мониторинга входа1
 a3a:	8a e0       	ldi	r24, 0x0A	; 10
 a3c:	90 e0       	ldi	r25, 0x00	; 0
 a3e:	60 e0       	ldi	r22, 0x00	; 0
 a40:	70 e0       	ldi	r23, 0x00	; 0
 a42:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
}
if (in2==1) { // датчик по входу2 подключен и не сработал
 a46:	b1 9b       	sbis	0x16, 1	; 22
 a48:	07 c0       	rjmp	.+14     	; 0xa58 <save_settings+0x4c>
 save_eeprom_data(11,1); // сохраняем в EEPROM состояние мониторинга входа1
 a4a:	8b e0       	ldi	r24, 0x0B	; 11
 a4c:	90 e0       	ldi	r25, 0x00	; 0
 a4e:	61 e0       	ldi	r22, 0x01	; 1
 a50:	70 e0       	ldi	r23, 0x00	; 0
 a52:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
 a56:	06 c0       	rjmp	.+12     	; 0xa64 <save_settings+0x58>
} else {
 save_eeprom_data(11,0); // сохраняем в EEPROM состояние мониторинга входа1
 a58:	8b e0       	ldi	r24, 0x0B	; 11
 a5a:	90 e0       	ldi	r25, 0x00	; 0
 a5c:	60 e0       	ldi	r22, 0x00	; 0
 a5e:	70 e0       	ldi	r23, 0x00	; 0
 a60:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
}
if (in3==1) { // датчик по входу3 подключен и не сработал
 a64:	b2 9b       	sbis	0x16, 2	; 22
 a66:	07 c0       	rjmp	.+14     	; 0xa76 <save_settings+0x6a>
 save_eeprom_data(12,1); // сохраняем в EEPROM состояние мониторинга входа1
 a68:	8c e0       	ldi	r24, 0x0C	; 12
 a6a:	90 e0       	ldi	r25, 0x00	; 0
 a6c:	61 e0       	ldi	r22, 0x01	; 1
 a6e:	70 e0       	ldi	r23, 0x00	; 0
 a70:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
 a74:	06 c0       	rjmp	.+12     	; 0xa82 <save_settings+0x76>
} else {
 save_eeprom_data(12,0); // сохраняем в EEPROM состояние мониторинга входа1
 a76:	8c e0       	ldi	r24, 0x0C	; 12
 a78:	90 e0       	ldi	r25, 0x00	; 0
 a7a:	60 e0       	ldi	r22, 0x00	; 0
 a7c:	70 e0       	ldi	r23, 0x00	; 0
 a7e:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
}
if (in4==1) { // датчик по входу4 подключен и не сработал
 a82:	b3 9b       	sbis	0x16, 3	; 22
 a84:	07 c0       	rjmp	.+14     	; 0xa94 <save_settings+0x88>
 save_eeprom_data(13,1); // сохраняем в EEPROM состояние мониторинга входа1
 a86:	8d e0       	ldi	r24, 0x0D	; 13
 a88:	90 e0       	ldi	r25, 0x00	; 0
 a8a:	61 e0       	ldi	r22, 0x01	; 1
 a8c:	70 e0       	ldi	r23, 0x00	; 0
 a8e:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
 a92:	06 c0       	rjmp	.+12     	; 0xaa0 <save_settings+0x94>
} else {
 save_eeprom_data(13,0); // сохраняем в EEPROM состояние мониторинга входа1
 a94:	8d e0       	ldi	r24, 0x0D	; 13
 a96:	90 e0       	ldi	r25, 0x00	; 0
 a98:	60 e0       	ldi	r22, 0x00	; 0
 a9a:	70 e0       	ldi	r23, 0x00	; 0
 a9c:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
}
if (in5==1) { // датчик по входу5 подключен и не сработал
 aa0:	b4 9b       	sbis	0x16, 4	; 22
 aa2:	07 c0       	rjmp	.+14     	; 0xab2 <save_settings+0xa6>
 save_eeprom_data(14,1); // сохраняем в EEPROM состояние мониторинга входа1
 aa4:	8e e0       	ldi	r24, 0x0E	; 14
 aa6:	90 e0       	ldi	r25, 0x00	; 0
 aa8:	61 e0       	ldi	r22, 0x01	; 1
 aaa:	70 e0       	ldi	r23, 0x00	; 0
 aac:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
 ab0:	06 c0       	rjmp	.+12     	; 0xabe <save_settings+0xb2>
} else {
 save_eeprom_data(14,0); // сохраняем в EEPROM состояние мониторинга входа1
 ab2:	8e e0       	ldi	r24, 0x0E	; 14
 ab4:	90 e0       	ldi	r25, 0x00	; 0
 ab6:	60 e0       	ldi	r22, 0x00	; 0
 ab8:	70 e0       	ldi	r23, 0x00	; 0
 aba:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
}
if (in6==1) { // датчик по входу6 подключен и не сработал
 abe:	b5 9b       	sbis	0x16, 5	; 22
 ac0:	07 c0       	rjmp	.+14     	; 0xad0 <save_settings+0xc4>
 save_eeprom_data(15,1); // сохраняем в EEPROM состояние мониторинга входа1
 ac2:	8f e0       	ldi	r24, 0x0F	; 15
 ac4:	90 e0       	ldi	r25, 0x00	; 0
 ac6:	61 e0       	ldi	r22, 0x01	; 1
 ac8:	70 e0       	ldi	r23, 0x00	; 0
 aca:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
 ace:	06 c0       	rjmp	.+12     	; 0xadc <save_settings+0xd0>
} else {
 save_eeprom_data(15,0); // сохраняем в EEPROM состояние мониторинга входа1
 ad0:	8f e0       	ldi	r24, 0x0F	; 15
 ad2:	90 e0       	ldi	r25, 0x00	; 0
 ad4:	60 e0       	ldi	r22, 0x00	; 0
 ad6:	70 e0       	ldi	r23, 0x00	; 0
 ad8:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
}
if (in7==1) { // датчик по входу7 подключен и не сработал
 adc:	b6 9b       	sbis	0x16, 6	; 22
 ade:	07 c0       	rjmp	.+14     	; 0xaee <save_settings+0xe2>
 save_eeprom_data(16,1); // сохраняем в EEPROM состояние мониторинга входа1
 ae0:	80 e1       	ldi	r24, 0x10	; 16
 ae2:	90 e0       	ldi	r25, 0x00	; 0
 ae4:	61 e0       	ldi	r22, 0x01	; 1
 ae6:	70 e0       	ldi	r23, 0x00	; 0
 ae8:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
 aec:	06 c0       	rjmp	.+12     	; 0xafa <save_settings+0xee>
} else {
 save_eeprom_data(16,0); // сохраняем в EEPROM состояние мониторинга входа1
 aee:	80 e1       	ldi	r24, 0x10	; 16
 af0:	90 e0       	ldi	r25, 0x00	; 0
 af2:	60 e0       	ldi	r22, 0x00	; 0
 af4:	70 e0       	ldi	r23, 0x00	; 0
 af6:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
}
if (in8==1) { // датчик по входу8 подключен и не сработал
 afa:	86 b3       	in	r24, 0x16	; 22
 afc:	88 23       	and	r24, r24
 afe:	3c f4       	brge	.+14     	; 0xb0e <save_settings+0x102>
 save_eeprom_data(17,1); // сохраняем в EEPROM состояние мониторинга входа1
 b00:	81 e1       	ldi	r24, 0x11	; 17
 b02:	90 e0       	ldi	r25, 0x00	; 0
 b04:	61 e0       	ldi	r22, 0x01	; 1
 b06:	70 e0       	ldi	r23, 0x00	; 0
 b08:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
 b0c:	06 c0       	rjmp	.+12     	; 0xb1a <save_settings+0x10e>
} else {
 save_eeprom_data(17,0); // сохраняем в EEPROM состояние мониторинга входа1
 b0e:	81 e1       	ldi	r24, 0x11	; 17
 b10:	90 e0       	ldi	r25, 0x00	; 0
 b12:	60 e0       	ldi	r22, 0x00	; 0
 b14:	70 e0       	ldi	r23, 0x00	; 0
 b16:	0e 94 d5 04 	call	0x9aa	; 0x9aa <save_eeprom_data>
}
beep_count=1; // пищим два раза после сохранения
 b1a:	81 e0       	ldi	r24, 0x01	; 1
 b1c:	80 93 b1 01 	sts	0x01B1, r24

}
 b20:	08 95       	ret

00000b22 <scan_botton>:
}

void scan_botton(void){
// проверяем нажатие на кнопки и выполняем соответствующие действия
unsigned int i;	
USART_Send_srt("processing of buttons");
 b22:	80 e3       	ldi	r24, 0x30	; 48
 b24:	91 e0       	ldi	r25, 0x01	; 1
 b26:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 if ((set_key>long_press) && (reset_key>long_press)){ // Долго вместе нажаты кнопки SET и RESET - сброс настроек устройства и сохранение их в EEPROM.
 b2a:	80 91 b6 01 	lds	r24, 0x01B6
 b2e:	90 91 b7 01 	lds	r25, 0x01B7
 b32:	8f 56       	subi	r24, 0x6F	; 111
 b34:	91 40       	sbci	r25, 0x01	; 1
 b36:	50 f0       	brcs	.+20     	; 0xb4c <scan_botton+0x2a>
 b38:	80 91 b4 01 	lds	r24, 0x01B4
 b3c:	90 91 b5 01 	lds	r25, 0x01B5
 b40:	8f 56       	subi	r24, 0x6F	; 111
 b42:	91 40       	sbci	r25, 0x01	; 1
 b44:	18 f0       	brcs	.+6      	; 0xb4c <scan_botton+0x2a>
  clean_and_reset(); 
 b46:	0e 94 df 04 	call	0x9be	; 0x9be <clean_and_reset>
 b4a:	5e c0       	rjmp	.+188    	; 0xc08 <scan_botton+0xe6>
 } else if (set_key>long_press){ // Долго нажата кнопка SET - запоминается состояние входов  и сохраняется в EEPROM.
 b4c:	80 91 b6 01 	lds	r24, 0x01B6
 b50:	90 91 b7 01 	lds	r25, 0x01B7
 b54:	8f 56       	subi	r24, 0x6F	; 111
 b56:	91 40       	sbci	r25, 0x01	; 1
 b58:	18 f0       	brcs	.+6      	; 0xb60 <scan_botton+0x3e>
         save_settings();
 b5a:	0e 94 06 05 	call	0xa0c	; 0xa0c <save_settings>
 b5e:	54 c0       	rjmp	.+168    	; 0xc08 <scan_botton+0xe6>
        } else if (reset_key>long_press){ // Долго нажата кнопка RESET - переход устройства в POWERDOWN или выход из него с задержкой включения 3 секунды.
 b60:	80 91 b4 01 	lds	r24, 0x01B4
 b64:	90 91 b5 01 	lds	r25, 0x01B5
 b68:	8f 56       	subi	r24, 0x6F	; 111
 b6a:	91 40       	sbci	r25, 0x01	; 1
 b6c:	68 f0       	brcs	.+26     	; 0xb88 <scan_botton+0x66>
		       go_sleep();
 b6e:	0e 94 9d 04 	call	0x93a	; 0x93a <go_sleep>
 b72:	20 e2       	ldi	r18, 0x20	; 32
 b74:	3e e4       	ldi	r19, 0x4E	; 78
 b76:	48 ec       	ldi	r20, 0xC8	; 200
 b78:	50 e0       	ldi	r21, 0x00	; 0
 b7a:	ca 01       	movw	r24, r20
 b7c:	01 97       	sbiw	r24, 0x01	; 1
 b7e:	f1 f7       	brne	.-4      	; 0xb7c <scan_botton+0x5a>
		{
			// wait 1/10 ms
			_delay_loop_2(((F_CPU) / 4e3) / 10);
			__ticks --;
 b80:	21 50       	subi	r18, 0x01	; 1
 b82:	30 40       	sbci	r19, 0x00	; 0
		__ticks = 1;
	else if (__tmp > 65535)
	{
		//	__ticks = requested delay in 1/10 ms
		__ticks = (uint16_t) (__ms * 10.0);
		while(__ticks)
 b84:	d1 f7       	brne	.-12     	; 0xb7a <scan_botton+0x58>
 b86:	40 c0       	rjmp	.+128    	; 0xc08 <scan_botton+0xe6>
			   _delay_ms(2000);
			   } else if (reset_key>quick_press) { // Быстро нажата кнопка RESET
 b88:	80 91 b4 01 	lds	r24, 0x01B4
 b8c:	90 91 b5 01 	lds	r25, 0x01B5
 b90:	ce 97       	sbiw	r24, 0x3e	; 62
 b92:	88 f0       	brcs	.+34     	; 0xbb6 <scan_botton+0x94>
 b94:	e8 ea       	ldi	r30, 0xA8	; 168
 b96:	f1 e0       	ldi	r31, 0x01	; 1
			             // прекращается мигание светодиодов входов (на светодиодах отображается текущее состояние входов)
					   for (i=0;i<max_in;i++){ // перебираем массив с настройками входов
 b98:	80 eb       	ldi	r24, 0xB0	; 176
 b9a:	91 e0       	ldi	r25, 0x01	; 1
                        led_status[i]=0; // обнуляем состояние светодиодов
 b9c:	11 92       	st	Z+, r1
        } else if (reset_key>long_press){ // Долго нажата кнопка RESET - переход устройства в POWERDOWN или выход из него с задержкой включения 3 секунды.
		       go_sleep();
			   _delay_ms(2000);
			   } else if (reset_key>quick_press) { // Быстро нажата кнопка RESET
			             // прекращается мигание светодиодов входов (на светодиодах отображается текущее состояние входов)
					   for (i=0;i<max_in;i++){ // перебираем массив с настройками входов
 b9e:	e8 17       	cp	r30, r24
 ba0:	f9 07       	cpc	r31, r25
 ba2:	e1 f7       	brne	.-8      	; 0xb9c <scan_botton+0x7a>
                        led_status[i]=0; // обнуляем состояние светодиодов
                       }
                       beep_count=0;
 ba4:	10 92 b1 01 	sts	0x01B1, r1
					   alarm=0;
 ba8:	10 92 b2 01 	sts	0x01B2, r1
					   USART_Send_srt("ALARM RESET AND LEDS RESET AND SPEAKET OFF");
 bac:	86 e4       	ldi	r24, 0x46	; 70
 bae:	91 e0       	ldi	r25, 0x01	; 1
 bb0:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 bb4:	29 c0       	rjmp	.+82     	; 0xc08 <scan_botton+0xe6>
					  }else if (hot_tap_key>quick_press){ // Быстро нажата кнопка "вкл/выкл гор. воды" - на сигнал управления краном горячей воды подается низкий уровень и кран закрывается, светодиод состояния крана горит красным. Повторное нажатие открывает кран, и светодиод состояния крана горит зеленым.
 bb6:	80 91 b8 01 	lds	r24, 0x01B8
 bba:	90 91 b9 01 	lds	r25, 0x01B9
 bbe:	ce 97       	sbiw	r24, 0x3e	; 62
 bc0:	78 f0       	brcs	.+30     	; 0xbe0 <scan_botton+0xbe>
					         if (tap_status[1]==0){tap_status[1]=1;}else{tap_status[1]=0;};
 bc2:	80 91 a7 01 	lds	r24, 0x01A7
 bc6:	88 23       	and	r24, r24
 bc8:	21 f4       	brne	.+8      	; 0xbd2 <scan_botton+0xb0>
 bca:	81 e0       	ldi	r24, 0x01	; 1
 bcc:	80 93 a7 01 	sts	0x01A7, r24
 bd0:	02 c0       	rjmp	.+4      	; 0xbd6 <scan_botton+0xb4>
 bd2:	10 92 a7 01 	sts	0x01A7, r1
							 USART_Send_srt("HOT TAP INVERT");
 bd6:	81 e7       	ldi	r24, 0x71	; 113
 bd8:	91 e0       	ldi	r25, 0x01	; 1
 bda:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
 bde:	14 c0       	rjmp	.+40     	; 0xc08 <scan_botton+0xe6>
							} else if (cold_tap_key>quick_press){ // Быстро нажата кнопка "вкл/выкл хол. воды" - на сигнал управления краном холодной воды подается низкий уровень и кран закрывается, светодиод состояния крана горит красным. Повторное нажатие открывает кран, и светодиод состояния крана горит зеленым.
 be0:	80 91 ba 01 	lds	r24, 0x01BA
 be4:	90 91 bb 01 	lds	r25, 0x01BB
 be8:	ce 97       	sbiw	r24, 0x3e	; 62
 bea:	70 f0       	brcs	.+28     	; 0xc08 <scan_botton+0xe6>
							        if (tap_status[0]==0){tap_status[0]=1;}else{tap_status[0]=0;};
 bec:	80 91 a6 01 	lds	r24, 0x01A6
 bf0:	88 23       	and	r24, r24
 bf2:	21 f4       	brne	.+8      	; 0xbfc <scan_botton+0xda>
 bf4:	81 e0       	ldi	r24, 0x01	; 1
 bf6:	80 93 a6 01 	sts	0x01A6, r24
 bfa:	02 c0       	rjmp	.+4      	; 0xc00 <scan_botton+0xde>
 bfc:	10 92 a6 01 	sts	0x01A6, r1
									USART_Send_srt("COLD TAP INVERT");
 c00:	80 e8       	ldi	r24, 0x80	; 128
 c02:	91 e0       	ldi	r25, 0x01	; 1
 c04:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>
								   }
botton_ready=0; // сбрасываем флаг необходимости обработки нажатия кнопок
 c08:	10 92 bc 01 	sts	0x01BC, r1
reset_key=0; // обнуляем счетчик времени нажатия на кнопку RESET
 c0c:	10 92 b5 01 	sts	0x01B5, r1
 c10:	10 92 b4 01 	sts	0x01B4, r1
set_key=0; // обнуляем счетчик времени нажатия на кнопку SET
 c14:	10 92 b7 01 	sts	0x01B7, r1
 c18:	10 92 b6 01 	sts	0x01B6, r1
hot_tap_key=0; // обнуляем счетчик времени нажатия на кнопку вкл/выкл горячей воды
 c1c:	10 92 b9 01 	sts	0x01B9, r1
 c20:	10 92 b8 01 	sts	0x01B8, r1
cold_tap_key=0; // обнуляем счетчик времени нажатия на кнопку вкл/выкл холодной воды
 c24:	10 92 bb 01 	sts	0x01BB, r1
 c28:	10 92 ba 01 	sts	0x01BA, r1
}
 c2c:	08 95       	ret

00000c2e <load_settings>:
   USART_Send((int)(*pTxT));
   ++pTxT;
 }
}

void load_settings(void){
 c2e:	0f 93       	push	r16
 c30:	1f 93       	push	r17
 c32:	cf 93       	push	r28
 c34:	df 93       	push	r29
//загружаем настройки входов и кранов из eeprom
unsigned int i;	

USART_Send_srt("load_settings");
 c36:	80 e9       	ldi	r24, 0x90	; 144
 c38:	91 e0       	ldi	r25, 0x01	; 1
 c3a:	0e 94 7f 00 	call	0xfe	; 0xfe <USART_Send_srt>

if (eeprom_read_byte((uint8_t*)9)!=0xFF) { //проверяем есть ли сохраненные настройки входов в eeprom
 c3e:	89 e0       	ldi	r24, 0x09	; 9
 c40:	90 e0       	ldi	r25, 0x00	; 0
 c42:	0e 94 95 06 	call	0xd2a	; 0xd2a <__eerd_byte_m16>
 c46:	8f 3f       	cpi	r24, 0xFF	; 255
 c48:	41 f0       	breq	.+16     	; 0xc5a <load_settings+0x2c>
 set_status=1; //есть
 c4a:	81 e0       	ldi	r24, 0x01	; 1
 c4c:	80 93 b0 01 	sts	0x01B0, r24
 c50:	ca e0       	ldi	r28, 0x0A	; 10
 c52:	d0 e0       	ldi	r29, 0x00	; 0
 set_status=0; //нет
 beep_count=1; // пищам один раз при включении
}
if (set_status!=0){ //читаем настройких входов из eeprom
 for (i=0;i<max_in;i++){
  In_status[i]=eeprom_read_byte((uint8_t*)i+10); //читаем значение входов из eeprom в массив
 c54:	0e e9       	ldi	r16, 0x9E	; 158
 c56:	11 e0       	ldi	r17, 0x01	; 1
 c58:	06 c0       	rjmp	.+12     	; 0xc66 <load_settings+0x38>
USART_Send_srt("load_settings");

if (eeprom_read_byte((uint8_t*)9)!=0xFF) { //проверяем есть ли сохраненные настройки входов в eeprom
 set_status=1; //есть
} else{
 set_status=0; //нет
 c5a:	10 92 b0 01 	sts	0x01B0, r1
 beep_count=1; // пищам один раз при включении
 c5e:	81 e0       	ldi	r24, 0x01	; 1
 c60:	80 93 b1 01 	sts	0x01B1, r24
 c64:	1b c0       	rjmp	.+54     	; 0xc9c <load_settings+0x6e>
}
if (set_status!=0){ //читаем настройких входов из eeprom
 for (i=0;i<max_in;i++){
  In_status[i]=eeprom_read_byte((uint8_t*)i+10); //читаем значение входов из eeprom в массив
 c66:	ce 01       	movw	r24, r28
 c68:	0e 94 95 06 	call	0xd2a	; 0xd2a <__eerd_byte_m16>
 c6c:	f8 01       	movw	r30, r16
 c6e:	ec 0f       	add	r30, r28
 c70:	fd 1f       	adc	r31, r29
 c72:	3a 97       	sbiw	r30, 0x0a	; 10
 c74:	80 83       	st	Z, r24
 c76:	21 96       	adiw	r28, 0x01	; 1
} else{
 set_status=0; //нет
 beep_count=1; // пищам один раз при включении
}
if (set_status!=0){ //читаем настройких входов из eeprom
 for (i=0;i<max_in;i++){
 c78:	c2 31       	cpi	r28, 0x12	; 18
 c7a:	d1 05       	cpc	r29, r1
 c7c:	a1 f7       	brne	.-24     	; 0xc66 <load_settings+0x38>
  In_status[i]=eeprom_read_byte((uint8_t*)i+10); //читаем значение входов из eeprom в массив
 }

 for (i=0;i<2;i++){ // читаем настройки кранов из eeprom
  tap_status[i]=eeprom_read_byte((uint8_t*)i+20); //читаем значение кранов из eeprom в массив
 c7e:	84 e1       	ldi	r24, 0x14	; 20
 c80:	90 e0       	ldi	r25, 0x00	; 0
 c82:	0e 94 95 06 	call	0xd2a	; 0xd2a <__eerd_byte_m16>
 c86:	06 ea       	ldi	r16, 0xA6	; 166
 c88:	11 e0       	ldi	r17, 0x01	; 1
 c8a:	f8 01       	movw	r30, r16
 c8c:	81 93       	st	Z+, r24
 c8e:	8f 01       	movw	r16, r30
 c90:	85 e1       	ldi	r24, 0x15	; 21
 c92:	90 e0       	ldi	r25, 0x00	; 0
 c94:	0e 94 95 06 	call	0xd2a	; 0xd2a <__eerd_byte_m16>
 c98:	f8 01       	movw	r30, r16
 c9a:	80 83       	st	Z, r24
 }

}
}
 c9c:	df 91       	pop	r29
 c9e:	cf 91       	pop	r28
 ca0:	1f 91       	pop	r17
 ca2:	0f 91       	pop	r16
 ca4:	08 95       	ret

00000ca6 <main>:
cold_tap_key=0; // обнуляем счетчик времени нажатия на кнопку вкл/выкл холодной воды
}

int main(void)
{
main_init(); // инициализируем ножки, таймеры и перефирию
 ca6:	0e 94 6b 04 	call	0x8d6	; 0x8d6 <main_init>
 caa:	80 e3       	ldi	r24, 0x30	; 48
 cac:	95 e7       	ldi	r25, 0x75	; 117
 cae:	28 ec       	ldi	r18, 0xC8	; 200
 cb0:	30 e0       	ldi	r19, 0x00	; 0
 cb2:	f9 01       	movw	r30, r18
 cb4:	31 97       	sbiw	r30, 0x01	; 1
 cb6:	f1 f7       	brne	.-4      	; 0xcb4 <main+0xe>
		{
			// wait 1/10 ms
			_delay_loop_2(((F_CPU) / 4e3) / 10);
			__ticks --;
 cb8:	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)
 cba:	d9 f7       	brne	.-10     	; 0xcb2 <main+0xc>
_delay_ms(3000);
load_settings(); //загружаем настройки из eeprom
 cbc:	0e 94 17 06 	call	0xc2e	; 0xc2e <load_settings>
tap_setting(); //устанавливаем краны в зависимости от начения в массиве
 cc0:	0e 94 9c 00 	call	0x138	; 0x138 <tap_setting>
set_leds(); // устанавливаем светодиоды в матрице в зависимости от массива их состояния (меппинг)
 cc4:	0e 94 1a 03 	call	0x634	; 0x634 <set_leds>
while(1)
 { //начало бесконечного цикла
  input_check(); // проверяем состояние входов, поднимаем аварию и изменяем состояние светодидов
 cc8:	0e 94 bb 00 	call	0x176	; 0x176 <input_check>
  tap_setting(); // устанавливаем краны в зависимости от начения в массиве
 ccc:	0e 94 9c 00 	call	0x138	; 0x138 <tap_setting>
  set_leds(); // устанавливаем светодиоды в матрице в зависимости от массива их состояния (меппинг)
 cd0:	0e 94 1a 03 	call	0x634	; 0x634 <set_leds>
  alarm_reset(); // сбрасываем флаг аварии и переключаем светодиоды входов на мигание
 cd4:	0e 94 14 02 	call	0x428	; 0x428 <alarm_reset>
  if (botton_ready==1) {scan_botton();} // проверяем нажатие кнопок
 cd8:	80 91 bc 01 	lds	r24, 0x01BC
 cdc:	81 30       	cpi	r24, 0x01	; 1
 cde:	a1 f7       	brne	.-24     	; 0xcc8 <main+0x22>
 ce0:	0e 94 91 05 	call	0xb22	; 0xb22 <scan_botton>
 ce4:	f1 cf       	rjmp	.-30     	; 0xcc8 <main+0x22>

00000ce6 <__udivmodsi4>:
 ce6:	a1 e2       	ldi	r26, 0x21	; 33
 ce8:	1a 2e       	mov	r1, r26
 cea:	aa 1b       	sub	r26, r26
 cec:	bb 1b       	sub	r27, r27
 cee:	fd 01       	movw	r30, r26
 cf0:	0d c0       	rjmp	.+26     	; 0xd0c <__udivmodsi4_ep>

00000cf2 <__udivmodsi4_loop>:
 cf2:	aa 1f       	adc	r26, r26
 cf4:	bb 1f       	adc	r27, r27
 cf6:	ee 1f       	adc	r30, r30
 cf8:	ff 1f       	adc	r31, r31
 cfa:	a2 17       	cp	r26, r18
 cfc:	b3 07       	cpc	r27, r19
 cfe:	e4 07       	cpc	r30, r20
 d00:	f5 07       	cpc	r31, r21
 d02:	20 f0       	brcs	.+8      	; 0xd0c <__udivmodsi4_ep>
 d04:	a2 1b       	sub	r26, r18
 d06:	b3 0b       	sbc	r27, r19
 d08:	e4 0b       	sbc	r30, r20
 d0a:	f5 0b       	sbc	r31, r21

00000d0c <__udivmodsi4_ep>:
 d0c:	66 1f       	adc	r22, r22
 d0e:	77 1f       	adc	r23, r23
 d10:	88 1f       	adc	r24, r24
 d12:	99 1f       	adc	r25, r25
 d14:	1a 94       	dec	r1
 d16:	69 f7       	brne	.-38     	; 0xcf2 <__udivmodsi4_loop>
 d18:	60 95       	com	r22
 d1a:	70 95       	com	r23
 d1c:	80 95       	com	r24
 d1e:	90 95       	com	r25
 d20:	9b 01       	movw	r18, r22
 d22:	ac 01       	movw	r20, r24
 d24:	bd 01       	movw	r22, r26
 d26:	cf 01       	movw	r24, r30
 d28:	08 95       	ret

00000d2a <__eerd_byte_m16>:
 d2a:	e1 99       	sbic	0x1c, 1	; 28
 d2c:	fe cf       	rjmp	.-4      	; 0xd2a <__eerd_byte_m16>
 d2e:	9f bb       	out	0x1f, r25	; 31
 d30:	8e bb       	out	0x1e, r24	; 30
 d32:	e0 9a       	sbi	0x1c, 0	; 28
 d34:	99 27       	eor	r25, r25
 d36:	8d b3       	in	r24, 0x1d	; 29
 d38:	08 95       	ret

00000d3a <__eewr_byte_m16>:
 d3a:	26 2f       	mov	r18, r22

00000d3c <__eewr_r18_m16>:
 d3c:	e1 99       	sbic	0x1c, 1	; 28
 d3e:	fe cf       	rjmp	.-4      	; 0xd3c <__eewr_r18_m16>
 d40:	9f bb       	out	0x1f, r25	; 31
 d42:	8e bb       	out	0x1e, r24	; 30
 d44:	2d bb       	out	0x1d, r18	; 29
 d46:	0f b6       	in	r0, 0x3f	; 63
 d48:	f8 94       	cli
 d4a:	e2 9a       	sbi	0x1c, 2	; 28
 d4c:	e1 9a       	sbi	0x1c, 1	; 28
 d4e:	0f be       	out	0x3f, r0	; 63
 d50:	01 96       	adiw	r24, 0x01	; 1
 d52:	08 95       	ret

00000d54 <_exit>:
 d54:	f8 94       	cli

00000d56 <__stop_program>:
 d56:	ff cf       	rjmp	.-2      	; 0xd56 <__stop_program>
