
main.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         0000015a  00000000  00000000  00000074  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .bss          00000001  00800060  00800060  000001ce  2**0
                  ALLOC
  2 .stab         000008dc  00000000  00000000  000001d0  2**2
                  CONTENTS, READONLY, DEBUGGING
  3 .stabstr      0000086c  00000000  00000000  00000aac  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
   0:	09 c0       	rjmp	.+18     	; 0x14 <__ctors_end>
   2:	16 c0       	rjmp	.+44     	; 0x30 <__bad_interrupt>
   4:	15 c0       	rjmp	.+42     	; 0x30 <__bad_interrupt>
   6:	14 c0       	rjmp	.+40     	; 0x30 <__bad_interrupt>
   8:	13 c0       	rjmp	.+38     	; 0x30 <__bad_interrupt>
   a:	12 c0       	rjmp	.+36     	; 0x30 <__bad_interrupt>
   c:	11 c0       	rjmp	.+34     	; 0x30 <__bad_interrupt>
   e:	10 c0       	rjmp	.+32     	; 0x30 <__bad_interrupt>
  10:	0f c0       	rjmp	.+30     	; 0x30 <__bad_interrupt>
  12:	0e c0       	rjmp	.+28     	; 0x30 <__bad_interrupt>

00000014 <__ctors_end>:
  14:	11 24       	eor	r1, r1
  16:	1f be       	out	0x3f, r1	; 63
  18:	cf e9       	ldi	r28, 0x9F	; 159
  1a:	cd bf       	out	0x3d, r28	; 61

0000001c <__do_clear_bss>:
  1c:	10 e0       	ldi	r17, 0x00	; 0
  1e:	a0 e6       	ldi	r26, 0x60	; 96
  20:	b0 e0       	ldi	r27, 0x00	; 0
  22:	01 c0       	rjmp	.+2      	; 0x26 <.do_clear_bss_start>

00000024 <.do_clear_bss_loop>:
  24:	1d 92       	st	X+, r1

00000026 <.do_clear_bss_start>:
  26:	a1 36       	cpi	r26, 0x61	; 97
  28:	b1 07       	cpc	r27, r17
  2a:	e1 f7       	brne	.-8      	; 0x24 <.do_clear_bss_loop>
  2c:	25 d0       	rcall	.+74     	; 0x78 <main>
  2e:	93 c0       	rjmp	.+294    	; 0x156 <_exit>

00000030 <__bad_interrupt>:
  30:	e7 cf       	rjmp	.-50     	; 0x0 <__vectors>

00000032 <data_to_synt>:
//--------------------------------------------------------------
//************** Отправка 8 бит в синтезатор *******************
//--------------------------------------------------------------

void data_to_synt (void) 
{
  32:	28 e0       	ldi	r18, 0x08	; 8
    can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
	__asm__ volatile (
  34:	30 ef       	ldi	r19, 0xF0	; 240
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
  36:	40 ef       	ldi	r20, 0xF0	; 240
  38:	50 e0       	ldi	r21, 0x00	; 0
/* Цикл вывода bayt начиная с бита_7 (старший - MSB). 
Будем делать 8 раз каждый раз отправляя в синтезатор очередной бит */

while (ctr)
   {
    if (bayt & 0b10000000) DATA_1;   // Вывести на DATA 7-й бит bayt
  3a:	80 91 60 00 	lds	r24, 0x0060
  3e:	87 ff       	sbrs	r24, 7
  40:	02 c0       	rjmp	.+4      	; 0x46 <__SREG__+0x7>
  42:	c4 9a       	sbi	0x18, 4	; 24
  44:	01 c0       	rjmp	.+2      	; 0x48 <__SREG__+0x9>
    
	else DATA_0; 
  46:	c4 98       	cbi	0x18, 4	; 24

    bayt <<= 1;    // Сдвинуть bayt на 1 позицию влево
  48:	80 91 60 00 	lds	r24, 0x0060
  4c:	88 0f       	add	r24, r24
  4e:	80 93 60 00 	sts	0x0060, r24
    ctr --;        // Уменьшить счетчик оставшихся прогонов цикла на 1
  52:	21 50       	subi	r18, 0x01	; 1
    can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
	__asm__ volatile (
  54:	83 2f       	mov	r24, r19
  56:	8a 95       	dec	r24
  58:	f1 f7       	brne	.-4      	; 0x56 <__SREG__+0x17>
  
   _delay_us(150);  //150 mks
   
    CLK_1;         //Сделать фронт на CLK 
  5a:	c3 9a       	sbi	0x18, 3	; 24
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
  5c:	ca 01       	movw	r24, r20
  5e:	01 97       	sbiw	r24, 0x01	; 1
  60:	f1 f7       	brne	.-4      	; 0x5e <__SREG__+0x1f>

   _delay_us(200); //задержка 200 мксек;	

    CLK_0;         //делать спад на CLK 
  62:	c3 98       	cbi	0x18, 3	; 24
    can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
	__asm__ volatile (
  64:	83 2f       	mov	r24, r19
  66:	8a 95       	dec	r24
  68:	f1 f7       	brne	.-4      	; 0x66 <__SREG__+0x27>
 unsigned char ctr = 8;          // Локальная переменная счетчик

/* Цикл вывода bayt начиная с бита_7 (старший - MSB). 
Будем делать 8 раз каждый раз отправляя в синтезатор очередной бит */

while (ctr)
  6a:	22 23       	and	r18, r18
  6c:	31 f7       	brne	.-52     	; 0x3a <__CCP__+0x6>
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
  6e:	80 ef       	ldi	r24, 0xF0	; 240
  70:	90 e0       	ldi	r25, 0x00	; 0
  72:	01 97       	sbiw	r24, 0x01	; 1
  74:	f1 f7       	brne	.-4      	; 0x72 <__SREG__+0x33>

   };
 
   _delay_us(200); //задержка 200 мксек;  

} 
  76:	08 95       	ret

00000078 <main>:
//////////////////////  M   A   I   N  /////////////////////////////
////////////////////////////////////////////////////////////////////
*/

int main(void)
{
  78:	ef 92       	push	r14
  7a:	ff 92       	push	r15
  7c:	0f 93       	push	r16
  7e:	1f 93       	push	r17
  80:	80 ed       	ldi	r24, 0xD0	; 208
  82:	97 e0       	ldi	r25, 0x07	; 7
  84:	28 e7       	ldi	r18, 0x78	; 120
  86:	30 e0       	ldi	r19, 0x00	; 0
  88:	f9 01       	movw	r30, r18
  8a:	31 97       	sbiw	r30, 0x01	; 1
  8c:	f1 f7       	brne	.-4      	; 0x8a <main+0x12>
		__ticks = (uint16_t) (__ms * 10.0);
		while(__ticks)
		{
			// wait 1/10 ms
			_delay_loop_2(((F_CPU) / 4e3) / 10);
			__ticks --;
  8e:	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)
  90:	d9 f7       	brne	.-10     	; 0x88 <main+0x10>
  
	_delay_ms(200);   //на переходные процессы

	CS_LINE_ON;       //Включаем линии (выводы МК) управляющие синтезатором  
  92:	ba 9a       	sbi	0x17, 2	; 23
	CLK_LINE_ON;      //делаем их выходами
  94:	bb 9a       	sbi	0x17, 3	; 23
	DATA_LINE_ON;     // линия DATA просто включена - сделана выходом
  96:	bc 9a       	sbi	0x17, 4	; 23

	CS_1;             //Установить "1" на CS (LE)
  98:	c2 9a       	sbi	0x18, 2	; 24
	CLK_0;            //Установить "0" на CLK
  9a:	c3 98       	cbi	0x18, 3	; 24
	DATA_0;           //Установить "0" на DATA
  9c:	c4 98       	cbi	0x18, 4	; 24
  9e:	88 ee       	ldi	r24, 0xE8	; 232
  a0:	93 e0       	ldi	r25, 0x03	; 3
  a2:	28 e7       	ldi	r18, 0x78	; 120
  a4:	30 e0       	ldi	r19, 0x00	; 0
  a6:	f9 01       	movw	r30, r18
  a8:	31 97       	sbiw	r30, 0x01	; 1
  aa:	f1 f7       	brne	.-4      	; 0xa8 <__stack+0x9>
		{
			// wait 1/10 ms
			_delay_loop_2(((F_CPU) / 4e3) / 10);
			__ticks --;
  ac:	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)
  ae:	d9 f7       	brne	.-10     	; 0xa6 <__stack+0x7>
   _delay_ms(100);    //100ms
   
   	CS_0;             //разрешаем запись в синтезатор CS=0 (LE=0)  
  b0:	c2 98       	cbi	0x18, 2	; 24

	//		P = 32, current setting 2 = 2.5 mA, current setting 1 = 2.5mA,
	//		Timeout = 3 pfd cycles, CP enabled, PD polarity = negative
	//		muxout = Digital lock,
	
 	bayt = 0x8D;      //посылаем MSB первым 
  b2:	9d e8       	ldi	r25, 0x8D	; 141
  b4:	e9 2e       	mov	r14, r25
  b6:	e0 92 60 00 	sts	0x0060, r14
	data_to_synt ();  //отправляем в синтезатор байт
  ba:	bb df       	rcall	.-138    	; 0x32 <data_to_synt>
	
	bayt = 0x80;      //next 
  bc:	80 e8       	ldi	r24, 0x80	; 128
  be:	f8 2e       	mov	r15, r24
  c0:	f0 92 60 00 	sts	0x0060, r15
	data_to_synt ();  //отправляем в синтезатор байт
  c4:	b6 df       	rcall	.-148    	; 0x32 <data_to_synt>
	
	bayt = 0x13;      //next 
  c6:	83 e1       	ldi	r24, 0x13	; 19
  c8:	80 93 60 00 	sts	0x0060, r24
	data_to_synt (); 
  cc:	b2 df       	rcall	.-156    	; 0x32 <data_to_synt>

    CS_1;             //Вывести "1" на LE,конец передачи Initialization Latch
  ce:	c2 9a       	sbi	0x18, 2	; 24
  d0:	00 ee       	ldi	r16, 0xE0	; 224
  d2:	1e e2       	ldi	r17, 0x2E	; 46
  d4:	c8 01       	movw	r24, r16
  d6:	01 97       	sbiw	r24, 0x01	; 1
  d8:	f1 f7       	brne	.-4      	; 0xd6 <__stack+0x37>
	_delay_ms(10);    //10ms
	CS_0;             //разрешаем запись в синтезатор CS=0 (LE=0)
  da:	c2 98       	cbi	0x18, 2	; 24

//-----Запись в синтезатор Functional Latch 0x8D8012

 	bayt = 0x8D;      //посылаем MSB первым 
  dc:	e0 92 60 00 	sts	0x0060, r14
	data_to_synt ();  //отправляем в синтезатор байт
  e0:	a8 df       	rcall	.-176    	; 0x32 <data_to_synt>
	
	bayt = 0x80;      //next 
  e2:	f0 92 60 00 	sts	0x0060, r15
	data_to_synt ();  //отправляем в синтезатор байт
  e6:	a5 df       	rcall	.-182    	; 0x32 <data_to_synt>
	
	bayt = 0x12;      //next 
  e8:	82 e1       	ldi	r24, 0x12	; 18
  ea:	80 93 60 00 	sts	0x0060, r24
	data_to_synt (); 
  ee:	a1 df       	rcall	.-190    	; 0x32 <data_to_synt>

    CS_1;             //Вывести "1" на LE,конец передачи Functional Latch
  f0:	c2 9a       	sbi	0x18, 2	; 24
  f2:	c8 01       	movw	r24, r16
  f4:	01 97       	sbiw	r24, 0x01	; 1
  f6:	f1 f7       	brne	.-4      	; 0xf4 <__stack+0x55>
	_delay_ms(10);    //10ms
	CS_0;             //разрешаем запись в синтезатор CS=0 (LE=0)
  f8:	c2 98       	cbi	0x18, 2	; 24
//-----Запись в синтезатор R Counter Latch 0x100008 =>MSB 00010000 00000000 00001000 LSB	

	// 		R = 2, Anti-backlash width = 2.9ns, Precision = five cycles
	//		of phase less than 15ns before lock detect is set
	
 	bayt = 0x10;      //посылаем MSB первым 00010000
  fa:	80 e1       	ldi	r24, 0x10	; 16
  fc:	80 93 60 00 	sts	0x0060, r24
	data_to_synt ();  //отправляем в синтезатор байт
 100:	98 df       	rcall	.-208    	; 0x32 <data_to_synt>
	
	bayt = 0x00;      //next 00000000
 102:	10 92 60 00 	sts	0x0060, r1
	data_to_synt ();  //отправляем в синтезатор байт
 106:	95 df       	rcall	.-214    	; 0x32 <data_to_synt>
	
	bayt = 0x08;      //next 00001000
 108:	88 e0       	ldi	r24, 0x08	; 8
 10a:	80 93 60 00 	sts	0x0060, r24
	data_to_synt (); 
 10e:	91 df       	rcall	.-222    	; 0x32 <data_to_synt>

    CS_1;             //Вывести "1" на LE,конец передачи R Counter Latch
 110:	c2 9a       	sbi	0x18, 2	; 24
 112:	c8 01       	movw	r24, r16
 114:	01 97       	sbiw	r24, 0x01	; 1
 116:	f1 f7       	brne	.-4      	; 0x114 <__stack+0x75>
	_delay_ms(10);    //10ms
	CS_0;             //разрешаем запись в синтезатор CS=0 (LE=0)
 118:	c2 98       	cbi	0x18, 2	; 24

//-----Запись в синтезатор N Counter Latch 0x000F15 	

	// AB latch

 	bayt = 0x00;      //посылаем MSB первым 
 11a:	10 92 60 00 	sts	0x0060, r1
	data_to_synt ();  //отправляем в синтезатор байт
 11e:	89 df       	rcall	.-238    	; 0x32 <data_to_synt>
	
	bayt = 0x0F;      //next 
 120:	8f e0       	ldi	r24, 0x0F	; 15
 122:	80 93 60 00 	sts	0x0060, r24
	data_to_synt ();  //отправляем в синтезатор байт
 126:	85 df       	rcall	.-246    	; 0x32 <data_to_synt>
	
	bayt = 0x15;      //next 
 128:	85 e1       	ldi	r24, 0x15	; 21
 12a:	80 93 60 00 	sts	0x0060, r24
	data_to_synt (); 
 12e:	81 df       	rcall	.-254    	; 0x32 <data_to_synt>

    CS_1;             //Вывести "1" на LE,конец передачи N Counter Latch
 130:	c2 9a       	sbi	0x18, 2	; 24
 132:	88 ee       	ldi	r24, 0xE8	; 232
 134:	93 e0       	ldi	r25, 0x03	; 3
 136:	28 e7       	ldi	r18, 0x78	; 120
 138:	30 e0       	ldi	r19, 0x00	; 0
 13a:	f9 01       	movw	r30, r18
 13c:	31 97       	sbiw	r30, 0x01	; 1
 13e:	f1 f7       	brne	.-4      	; 0x13c <__stack+0x9d>
		{
			// wait 1/10 ms
			_delay_loop_2(((F_CPU) / 4e3) / 10);
			__ticks --;
 140:	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)
 142:	d9 f7       	brne	.-10     	; 0x13a <__stack+0x9b>
	_delay_ms(100);    //100ms

//----- Перевод контроллера в спящий режим --------
    
	set_sleep_mode(SLEEP_MODE_PWR_DOWN); // если спать - то на полную -->  Power-down
 144:	85 b7       	in	r24, 0x35	; 53
 146:	87 7e       	andi	r24, 0xE7	; 231
 148:	80 61       	ori	r24, 0x10	; 16
 14a:	85 bf       	out	0x35, r24	; 53
    while(1) 
	{
	 sleep_enable();   // разрешаем сон
 14c:	85 b7       	in	r24, 0x35	; 53
 14e:	80 62       	ori	r24, 0x20	; 32
 150:	85 bf       	out	0x35, r24	; 53
     sleep_cpu();      // спать!
 152:	88 95       	sleep
 154:	fb cf       	rjmp	.-10     	; 0x14c <__stack+0xad>

00000156 <_exit>:
 156:	f8 94       	cli

00000158 <__stop_program>:
 158:	ff cf       	rjmp	.-2      	; 0x158 <__stop_program>
