3.2 Підключення і налагоджування пристрою

У моєму приладі перед запуском треба запрограмувати мікросхему Attiny2313. Програмний код наведений нижче.

00000048 <__bad_interrupt>:

48: db cf rjmp .-74 ; 0x0 <__vectors>

0000004a <rtc_write>:

settings_data(59, 0, 0xCA, SECONDS_WRITE); // установка секунд

rtc_write_byte(CONTROL_REG, 0x0); // запуск внутреннего генератора

}

// rtc_write - функция записи байта в RTC

void rtc_write(uint8_t rtc_data)

{

4a: 90 e0 ldi r25, 0x00 ; 0

uint8_t buffer; // промежуточный буффер данных

for(i=0; i<8; ++i)

{

buffer=rtc_data; // копирование данных

buffer=buffer & 0x1; // выделение младшего бита

if (buffer==0x1)

4c: 80 ff sbrs r24, 0

4e: 02 c0 rjmp .+4 ; 0x54 <rtc_write+0xa>

{

PORTD=PORTD | (1<<DATA); // установка DATA

50: 93 9a sbi 0x12, 3 ; 18

52: 01 c0 rjmp .+2 ; 0x56 <rtc_write+0xc>

}

else

{

PORTD=PORTD & (~(1<<DATA)); // сброс DATA

54: 93 98 cbi 0x12, 3 ; 18

}

PORTD=PORTD | (1<<CLK); // установка CLK

56: 94 9a sbi 0x12, 4 ; 18

PORTD=PORTD & (~(1<<CLK)); // сброс CLK

58: 94 98 cbi 0x12, 4 ; 18

// rtc_write - функция записи байта в RTC

void rtc_write(uint8_t rtc_data)

{

uint8_t i; // промежуточный счетчик бит

uint8_t buffer; // промежуточный буффер данных

for(i=0; i<8; ++i)

5a: 9f 5f subi r25, 0xFF ; 255

5c: 98 30 cpi r25, 0x08 ; 8

5e: 11 f0 breq .+4 ; 0x64 <rtc_write+0x1a>

{

PORTD=PORTD & (~(1<<DATA)); // сброс DATA

}

PORTD=PORTD | (1<<CLK); // установка CLK

PORTD=PORTD & (~(1<<CLK)); // сброс CLK

rtc_data=rtc_data>>1; // сдвиг вправо

60: 86 95 lsr r24

62: f4 cf rjmp .-24 ; 0x4c <rtc_write+0x2>

64: 08 95 ret

00000066 <rtc_read>:

{

uint8_t i; // промежуточный счетчик бит

uint8_t buffer; // промежуточный буффер данных

uint8_t rtc_data; // данные

rtc_data=0x0; // начальное значение

PORTD=PORTD & (~(1<<DATA)); // настройка подтягивающего резистора линии DATA порта D

66: 93 98 cbi 0x12, 3 ; 18

DDRD=DDRD & (~(1<<DATA)); // настройка линии DATA порта D

68: 8b 98 cbi 0x11, 3 ; 17

6a: 40 e0 ldi r20, 0x00 ; 0

6c: 20 e0 ldi r18, 0x00 ; 0

6e: 30 e0 ldi r19, 0x00 ; 0

PORTD=PORTD | (1<<CLK); // установка CLK

PORTD=PORTD & (~(1<<CLK)); // сброс CLK

buffer=PIND & (1<<DATA); // чтение данных

if (buffer!=0)

{

rtc_data=rtc_data | (1<<i); // установка бита

70: 61 e0 ldi r22, 0x01 ; 1

72: 70 e0 ldi r23, 0x00 ; 0

rtc_data=0x0; // начальное значение

PORTD=PORTD & (~(1<<DATA)); // настройка подтягивающего резистора линии DATA порта D

DDRD=DDRD & (~(1<<DATA)); // настройка линии DATA порта D

for(i=0; i<8; ++i)

{

PORTD=PORTD | (1<<CLK); // установка CLK

74: 94 9a sbi 0x12, 4 ; 18

PORTD=PORTD & (~(1<<CLK)); // сброс CLK

76: 94 98 cbi 0x12, 4 ; 18

buffer=PIND & (1<<DATA); // чтение данных

if (buffer!=0)

78: 83 9b sbis 0x10, 3 ; 16

7a: 08 c0 rjmp .+16 ; 0x8c <rtc_read+0x26>

{

rtc_data=rtc_data | (1<<i); // установка бита

7c: cb 01 movw r24, r22

7e: 02 2e mov r0, r18

80: 02 c0 rjmp .+4 ; 0x86 <rtc_read+0x20>

82: 88 0f add r24, r24

84: 99 1f adc r25, r25

86: 0a 94 dec r0

88: e2 f7 brpl .-8 ; 0x82 <rtc_read+0x1c>

8a: 48 2b or r20, r24

8c: 2f 5f subi r18, 0xFF ; 255

8e: 3f 4f sbci r19, 0xFF ; 255

uint8_t buffer; // промежуточный буффер данных

uint8_t rtc_data; // данные

rtc_data=0x0; // начальное значение

PORTD=PORTD & (~(1<<DATA)); // настройка подтягивающего резистора линии DATA порта D

DDRD=DDRD & (~(1<<DATA)); // настройка линии DATA порта D

for(i=0; i<8; ++i)

90: 28 30 cpi r18, 0x08 ; 8

92: 31 05 cpc r19, r1

94: 79 f7 brne .-34 ; 0x74 <rtc_read+0xe>

if (buffer!=0)

{

rtc_data=rtc_data | (1<<i); // установка бита

}

}

PORTD=PORTD & (~(1<<CS)); // сброс CS

96: 95 98 cbi 0x12, 5 ; 18

DDRD=DDRD | (1<<DATA); // настройка линии DATA порта D

98: 8b 9a sbi 0x11, 3 ; 17

return rtc_data; // выход из функции

}

9a: 84 2f mov r24, r20

9c: 08 95 ret

0000009e <rtc_write_byte>:

// rtc_write_byte - функция записи данных в RTC

// address = 0xXX -> адрес байта

// rtc_data = 0xXX -> данные

void rtc_write_byte(uint8_t address, uint8_t rtc_data)

{

9e: 1f 93 push r17

a0: 16 2f mov r17, r22

PORTD=PORTD | (1<<CS); // выбор периферийного устройства

a2: 95 9a sbi 0x12, 5 ; 18

rtc_write(address); // запись данных

a4: d2 df rcall .-92 ; 0x4a <rtc_write>

rtc_write(rtc_data); // запись данных

a6: 81 2f mov r24, r17

a8: d0 df rcall .-96 ; 0x4a <rtc_write>

PORTD=PORTD & (~((1<<DATA) | (1<<CLK) | (1<<CS))); // сброс DATA, CLK, CS

aa: 82 b3 in r24, 0x12 ; 18

ac: 87 7c andi r24, 0xC7 ; 199

ae: 82 bb out 0x12, r24 ; 18

}

b0: 1f 91 pop r17

b2: 08 95 ret

000000b4 <rtc_read_byte>:

// rtc_read_byte - функция чтения данных из RTC

// address = 0xXX -> адрес байта

uint8_t rtc_read_byte(uint8_t address)

{

uint8_t rtc_data; // данные

PORTD=PORTD | (1<<CS); // выбор периферийного устройства

b4: 95 9a sbi 0x12, 5 ; 18

rtc_write(address); // запись данных

b6: c9 df rcall .-110 ; 0x4a <rtc_write>

rtc_data=rtc_read(); // чтение данных

b8: d6 df rcall .-84 ; 0x66 <rtc_read>

PORTD=PORTD & (~((1<<DATA) | (1<<CLK) | (1<<CS))); // сброс DATA, CLK, CS

ba: 92 b3 in r25, 0x12 ; 18

bc: 97 7c andi r25, 0xC7 ; 199

be: 92 bb out 0x12, r25 ; 18

return rtc_data; // выход из функции

}

c0: 08 95 ret

000000c2 <display_write_byte>:

// display_write_byte - функция записи байта в дисплей

// reg = 0/1 -> команда/данные

// bit = 0/1 -> разрядность 4/8 бит

// display_data = 0xXX -> данные

void display_write_byte(uint8_t reg, uint8_t bit, uint8_t display_data)

{

c2: 98 2f mov r25, r24

c4: 84 2f mov r24, r20

c6: 80 7f andi r24, 0xF0 ; 240

uint8_t buffer; // промежуточный буффер данных

if (bit==1)

c8: 61 30 cpi r22, 0x01 ; 1

ca: 21 f4 brne .+8 ; 0xd4 <display_write_byte+0x12>

{

// 8-битный режим

display_data=(display_data & 0xF0) | (1<<E); // установка E

cc: 88 60 ori r24, 0x08 ; 8

PORTB=display_data; // запись данных

ce: 88 bb out 0x18, r24 ; 24

display_data=display_data & 0xF0; // сброс E

d0: 80 7f andi r24, 0xF0 ; 240

d2: 0f c0 rjmp .+30 ; 0xf2 <__stack+0x13>

}

else

{

// 4-битный режим

buffer=display_data; // копирование данных

display_data=(display_data & 0xF0) | (reg<<RS) | (1<<E); // установка E

d4: 99 0f add r25, r25

d6: 29 2f mov r18, r25

d8: 28 60 ori r18, 0x08 ; 8

da: 82 2b or r24, r18

PORTB=display_data; // запись данных

dc: 88 bb out 0x18, r24 ; 24

display_data=(display_data & 0xF0) | (reg<<RS); // сброс E

de: 80 7f andi r24, 0xF0 ; 240

e0: 89 2b or r24, r25

PORTB=display_data; // запись данных

e2: 88 bb out 0x18, r24 ; 24

display_data=buffer; // копирование данных

display_data=display_data<<4; // сдвиг влево

display_data=(display_data & 0xF0) | (reg<<RS) | (1<<E); // установка E

e4: 84 2f mov r24, r20

e6: 82 95 swap r24

e8: 80 7f andi r24, 0xF0 ; 240

ea: 82 2b or r24, r18

PORTB=display_data; // запись данных

ec: 88 bb out 0x18, r24 ; 24

display_data=(display_data & 0xF0) | (reg<<RS); // сброс E

ee: 80 7f andi r24, 0xF0 ; 240

f0: 89 2b or r24, r25

PORTB=display_data; // запись данных

f2: 88 bb out 0x18, r24 ; 24

can be achieved.

*/

void

_delay_loop_1(uint8_t __count)

{

__asm__ volatile (

f4: 81 e2 ldi r24, 0x21 ; 33

f6: 8a 95 dec r24

f8: f1 f7 brne .-4 ; 0xf6 <__stack+0x17>

fa: 08 95 ret

000000fc <display_init>:

return rtc_data; // выход из функции

}

// WH1602B

// display_init - функция инициализации дисплея

void display_init(void)

{

fc: 0f 93 push r16

fe: 1f 93 push r17

milliseconds can be achieved.

*/

void

_delay_loop_2(uint16_t __count)

{

__asm__ volatile (

100: 08 e8 ldi r16, 0x88 ; 136

102: 13 e1 ldi r17, 0x13 ; 19

104: c8 01 movw r24, r16

106: 01 97 sbiw r24, 0x01 ; 1

108: f1 f7 brne .-4 ; 0x106 <display_init+0xa>

_delay_ms(20); // время установления питания

display_write_byte(0, 1, 0x3); // установка разрядности 8 бит

10a: 80 e0 ldi r24, 0x00 ; 0

10c: 61 e0 ldi r22, 0x01 ; 1

10e: 43 e0 ldi r20, 0x03 ; 3

110: d8 df rcall .-80 ; 0xc2 <display_write_byte>

display_write_byte(0, 1, 0x3); // установка разрядности 8 бит

112: 80 e0 ldi r24, 0x00 ; 0

114: 61 e0 ldi r22, 0x01 ; 1

116: 43 e0 ldi r20, 0x03 ; 3

118: d4 df rcall .-88 ; 0xc2 <display_write_byte>

display_write_byte(0, 1, 0x3); // установка разрядности 8 бит

11a: 80 e0 ldi r24, 0x00 ; 0

11c: 61 e0 ldi r22, 0x01 ; 1

11e: 43 e0 ldi r20, 0x03 ; 3

120: d0 df rcall .-96 ; 0xc2 <display_write_byte>

display_write_byte(0, 1, 0x2); // установка разрядности 4 бит

122: 80 e0 ldi r24, 0x00 ; 0

124: 61 e0 ldi r22, 0x01 ; 1

126: 42 e0 ldi r20, 0x02 ; 2

128: cc df rcall .-104 ; 0xc2 <display_write_byte>

display_write_byte(0, 0, 0x28); // установка параметров

12a: 80 e0 ldi r24, 0x00 ; 0

12c: 60 e0 ldi r22, 0x00 ; 0

12e: 48 e2 ldi r20, 0x28 ; 40

130: c8 df rcall .-112 ; 0xc2 <display_write_byte>

display_write_byte(0, 0, 0x8); // выключение дисплея

132: 80 e0 ldi r24, 0x00 ; 0

134: 60 e0 ldi r22, 0x00 ; 0

136: 48 e0 ldi r20, 0x08 ; 8

138: c4 df rcall .-120 ; 0xc2 <display_write_byte>

display_write_byte(0, 0, 0x1); // очистка дисплея

13a: 80 e0 ldi r24, 0x00 ; 0

13c: 60 e0 ldi r22, 0x00 ; 0

13e: 41 e0 ldi r20, 0x01 ; 1

140: c0 df rcall .-128 ; 0xc2 <display_write_byte>

142: c8 01 movw r24, r16

144: 01 97 sbiw r24, 0x01 ; 1

146: f1 f7 brne .-4 ; 0x144 <display_init+0x48>

_delay_ms(20); // время выполнения операции

display_write_byte(0, 0, 0x6); // установка режима ввода данных

148: 80 e0 ldi r24, 0x00 ; 0

14a: 60 e0 ldi r22, 0x00 ; 0

14c: 46 e0 ldi r20, 0x06 ; 6

14e: b9 df rcall .-142 ; 0xc2 <display_write_byte>

display_write_byte(0, 0, 0xC); // включение дисплея

150: 80 e0 ldi r24, 0x00 ; 0

152: 60 e0 ldi r22, 0x00 ; 0

154: 4c e0 ldi r20, 0x0C ; 12

156: b5 df rcall .-150 ; 0xc2 <display_write_byte>

}

158: 1f 91 pop r17

15a: 0f 91 pop r16

15c: 08 95 ret

0000015e <display_write_strong>:

}

// display_write_strong - функция записи строки в дисплей

// display_data[] = 0xXX -> строка данных

// size = x -> количество символов в строке

void display_write_strong(uint8_t display_data[], uint8_t size)

{

15e: 0f 93 push r16

160: 1f 93 push r17

162: cf 93 push r28

164: df 93 push r29

166: 06 2f mov r16, r22

168: ec 01 movw r28, r24

16a: 10 e0 ldi r17, 0x00 ; 0

16c: 05 c0 rjmp .+10 ; 0x178 <display_write_strong+0x1a>

uint8_t i; // промежуточный счетчик символов

for(i=0; i<size; ++i)

{

display_write_byte(1, 0, display_data[i]); // запись строки данных

16e: 81 e0 ldi r24, 0x01 ; 1

170: 60 e0 ldi r22, 0x00 ; 0

172: 49 91 ld r20, Y+

174: a6 df rcall .-180 ; 0xc2 <display_write_byte>

// display_data[] = 0xXX -> строка данных

// size = x -> количество символов в строке

void display_write_strong(uint8_t display_data[], uint8_t size)

{

uint8_t i; // промежуточный счетчик символов

for(i=0; i<size; ++i)

176: 1f 5f subi r17, 0xFF ; 255

178: 10 17 cp r17, r16

17a: c8 f3 brcs .-14 ; 0x16e <display_write_strong+0x10>

{

display_write_byte(1, 0, display_data[i]); // запись строки данных

}

}

17c: df 91 pop r29

17e: cf 91 pop r28

180: 1f 91 pop r17

182: 0f 91 pop r16

184: 08 95 ret

00000186 <display_write_bcd>:

data=rtc_read_byte(SECONDS_READ); // чтение данных секунд

display_write_bcd(data); // запись данных

}

// display_write_bcd - функция разделения числа BCD

void display_write_bcd(uint8_t display_data)

{

186: 1f 93 push r17

188: 18 2f mov r17, r24

uint8_t buffer; // промежуточный буффер данных

buffer=display_data; // копирование данных

display_data=display_data>>4; // сдвиг вправо

display_data=display_data & 0xF; // выделение младшего полубайта

18a: 48 2f mov r20, r24

18c: 42 95 swap r20

18e: 4f 70 andi r20, 0x0F ; 15

display_data=display_data | 0x30; // составление слова для записи в дисплей

display_write_byte(1, 0, display_data); // запись данных

190: 40 63 ori r20, 0x30 ; 48

192: 81 e0 ldi r24, 0x01 ; 1

194: 60 e0 ldi r22, 0x00 ; 0

196: 95 df rcall .-214 ; 0xc2 <display_write_byte>

display_data=buffer; // копирование данных

display_data=display_data & 0xF; // выделение младшего полубайта

198: 1f 70 andi r17, 0x0F ; 15

display_data=display_data | 0x30; // составление слова для записи в дисплей

display_write_byte(1, 0, display_data); // запись данных

19a: 10 63 ori r17, 0x30 ; 48

19c: 81 e0 ldi r24, 0x01 ; 1

19e: 60 e0 ldi r22, 0x00 ; 0

1a0: 41 2f mov r20, r17

1a2: 8f df rcall .-226 ; 0xc2 <display_write_byte>

1a4: 1f 91 pop r17

1a6: 08 95 ret

000001a8 <display_write_time>:

display_write_byte(1, 0, display_data[i]); // запись строки данных

}

}

// display_write_time - функция записи времени и даты в дисплей

void display_write_time(void)

{

1a8: ef 92 push r14

1aa: ff 92 push r15

1ac: 0f 93 push r16

1ae: 1f 93 push r17

uint8_t data; // данные

display_write_byte(0, 0, 0x2); // курсор в левую позицию

1b0: 80 e0 ldi r24, 0x00 ; 0

1b2: 60 e0 ldi r22, 0x00 ; 0

1b4: 42 e0 ldi r20, 0x02 ; 2

1b6: 85 df rcall .-246 ; 0xc2 <display_write_byte>

display_write_strong(" ", 4); // запись 4 пробелов (выравнивание даты)

1b8: 00 e6 ldi r16, 0x60 ; 96

1ba: 10 e0 ldi r17, 0x00 ; 0

1bc: c8 01 movw r24, r16

1be: 64 e0 ldi r22, 0x04 ; 4

1c0: ce df rcall .-100 ; 0x15e <display_write_strong>

data=rtc_read_byte(DATE_READ); // чтение данных дня месяца

1c2: 84 e0 ldi r24, 0x04 ; 4

1c4: 77 df rcall .-274 ; 0xb4 <rtc_read_byte>

display_write_bcd(data); // запись данных

1c6: df df rcall .-66 ; 0x186 <display_write_bcd>

display_write_strong(".", 1); // запись разделителя

1c8: 85 e6 ldi r24, 0x65 ; 101

1ca: e8 2e mov r14, r24

1cc: 80 e0 ldi r24, 0x00 ; 0

1ce: f8 2e mov r15, r24

1d0: c7 01 movw r24, r14

1d2: 61 e0 ldi r22, 0x01 ; 1

1d4: c4 df rcall .-120 ; 0x15e <display_write_strong>

data=rtc_read_byte(MONTH_READ); // чтение данных месяца

1d6: 85 e0 ldi r24, 0x05 ; 5

1d8: 6d df rcall .-294 ; 0xb4 <rtc_read_byte>

display_write_bcd(data); // запись данных

1da: d5 df rcall .-86 ; 0x186 <display_write_bcd>

display_write_strong(".", 1); // запись разделителя

1dc: c7 01 movw r24, r14

1de: 61 e0 ldi r22, 0x01 ; 1

1e0: be df rcall .-132 ; 0x15e <display_write_strong>

data=rtc_read_byte(YEAR_READ); // чтение данных года

1e2: 86 e0 ldi r24, 0x06 ; 6

1e4: 67 df rcall .-306 ; 0xb4 <rtc_read_byte>

display_write_bcd(data); // запись данных

1e6: cf df rcall .-98 ; 0x186 <display_write_bcd>

display_write_byte(0, 0, 0xC0); // переход на другую строку

1e8: 80 e0 ldi r24, 0x00 ; 0

1ea: 60 e0 ldi r22, 0x00 ; 0

1ec: 40 ec ldi r20, 0xC0 ; 192

1ee: 69 df rcall .-302 ; 0xc2 <display_write_byte>

display_write_strong(" ", 4); // запись 4 пробелов (выравнивание времени)

1f0: c8 01 movw r24, r16

1f2: 64 e0 ldi r22, 0x04 ; 4

1f4: b4 df rcall .-152 ; 0x15e <display_write_strong>

data=rtc_read_byte(HOURS_READ); // чтение данных часов

1f6: 82 e0 ldi r24, 0x02 ; 2

1f8: 5d df rcall .-326 ; 0xb4 <rtc_read_byte>

display_write_bcd(data); // запись данных

1fa: c5 df rcall .-118 ; 0x186 <display_write_bcd>

display_write_strong(":", 1); // запись разделителя

1fc: 07 e6 ldi r16, 0x67 ; 103

1fe: 10 e0 ldi r17, 0x00 ; 0

200: c8 01 movw r24, r16

202: 61 e0 ldi r22, 0x01 ; 1

204: ac df rcall .-168 ; 0x15e <display_write_strong>

data=rtc_read_byte(MINUTES_READ); // чтение данных минут

206: 81 e0 ldi r24, 0x01 ; 1

208: 55 df rcall .-342 ; 0xb4 <rtc_read_byte>

display_write_bcd(data); // запись данных

20a: bd df rcall .-134 ; 0x186 <display_write_bcd>

display_write_strong(":", 1); // запись разделителя

20c: c8 01 movw r24, r16

20e: 61 e0 ldi r22, 0x01 ; 1

210: a6 df rcall .-180 ; 0x15e <display_write_strong>

data=rtc_read_byte(SECONDS_READ); // чтение данных секунд

212: 80 e0 ldi r24, 0x00 ; 0

214: 4f df rcall .-354 ; 0xb4 <rtc_read_byte>

display_write_bcd(data); // запись данных

216: b7 df rcall .-146 ; 0x186 <display_write_bcd>

}

218: 1f 91 pop r17

21a: 0f 91 pop r16

21c: ff 90 pop r15

21e: ef 90 pop r14

220: 08 95 ret

00000222 <settings_data>:

// upper = n -> верхний предел

// lower = n -> нижний предел

// display_index = 0xXX -> адрес установки курсора

// address = 0xXX -> адрес байта

void settings_data(uint8_t upper, uint8_t lower, uint8_t display_index, uint8_t address)

{

222: cf 92 push r12

224: df 92 push r13

226: ef 92 push r14

228: ff 92 push r15

22a: 0f 93 push r16

22c: 1f 93 push r17

22e: cf 93 push r28

230: df 93 push r29

232: e8 2e mov r14, r24

234: f6 2e mov r15, r22

236: d4 2e mov r13, r20

238: c2 2e mov r12, r18

23a: 16 2f mov r17, r22

23c: 00 e0 ldi r16, 0x00 ; 0

23e: c0 e5 ldi r28, 0x50 ; 80

240: d3 ec ldi r29, 0xC3 ; 195

242: 2d c0 rjmp .+90 ; 0x29e <settings_data+0x7c>

i_0=lower; // начальное значение

buffer=0x0; // начальное значение

rtc_data=0x0; // начальное значение

while((PIND & (1<<SETTINGS))!=0)

{

display_write_byte(0, 0, display_index); // установка курсора

244: 80 e0 ldi r24, 0x00 ; 0

246: 60 e0 ldi r22, 0x00 ; 0

248: 4d 2d mov r20, r13

24a: 3b df rcall .-394 ; 0xc2 <display_write_byte>

24c: 91 2f mov r25, r17

24e: 80 e0 ldi r24, 0x00 ; 0

250: 00 e0 ldi r16, 0x00 ; 0

252: 09 c0 rjmp .+18 ; 0x266 <settings_data+0x44>

i_1=i_0; // копирование данных

buffer=0x0; // очистка промежуточного буффера данных

rtc_data=0x0; // очистка данных

while(i_1>0)

{

++buffer; // увеличение значения

254: 8f 5f subi r24, 0xFF ; 255

if(buffer>9)

256: 8a 30 cpi r24, 0x0A ; 10

258: 18 f0 brcs .+6 ; 0x260 <settings_data+0x3e>

{

buffer=0x0; // очистка промежуточного буффера данных

rtc_data=rtc_data>>4; // сдвиг вправо

rtc_data=rtc_data & 0xF; // выделение младшего полубайта

++rtc_data; // увеличение значения

25a: 00 7f andi r16, 0xF0 ; 240

rtc_data=rtc_data<<4; // сдвиг влево

25c: 00 5f subi r16, 0xF0 ; 240

25e: 80 e0 ldi r24, 0x00 ; 0

}

rtc_data=rtc_data & 0xF0; // выделение старшего полубайта

260: 00 7f andi r16, 0xF0 ; 240

rtc_data=rtc_data | buffer; // сложение полубайтов

262: 08 2b or r16, r24

--i_1; // уменьшение значения

264: 91 50 subi r25, 0x01 ; 1

{

display_write_byte(0, 0, display_index); // установка курсора

i_1=i_0; // копирование данных

buffer=0x0; // очистка промежуточного буффера данных

rtc_data=0x0; // очистка данных

while(i_1>0)

266: 99 23 and r25, r25

268: a9 f7 brne .-22 ; 0x254 <settings_data+0x32>

}

rtc_data=rtc_data & 0xF0; // выделение старшего полубайта

rtc_data=rtc_data | buffer; // сложение полубайтов

--i_1; // уменьшение значения

}

display_write_bcd(rtc_data); // запись данных

26a: 80 2f mov r24, r16

26c: 8c df rcall .-232 ; 0x186 <display_write_bcd>

if(i_0==lower)

26e: 1f 15 cp r17, r15

270: 19 f4 brne .+6 ; 0x278 <settings_data+0x56>

{

if((PIND & (1<<INCREMENT))==0)

272: 82 99 sbic 0x10, 2 ; 16

274: 14 c0 rjmp .+40 ; 0x29e <settings_data+0x7c>

276: 08 c0 rjmp .+16 ; 0x288 <settings_data+0x66>

{

_delay_ms(200); // антидребезг

++i_0; // увеличение значения

}

}

else if(i_0==upper)

278: 1e 15 cp r17, r14

27a: 59 f0 breq .+22 ; 0x292 <settings_data+0x70>

{

_delay_ms(200); // антидребезг

--i_0; // уменьшение значения

}

}

else if(i_0>lower && i_0<upper)

27c: f1 16 cp r15, r17

27e: 78 f4 brcc .+30 ; 0x29e <settings_data+0x7c>

280: 1e 15 cp r17, r14

282: 68 f4 brcc .+26 ; 0x29e <settings_data+0x7c>

{

if((PIND & (1<<INCREMENT))==0)

284: 82 99 sbic 0x10, 2 ; 16

286: 05 c0 rjmp .+10 ; 0x292 <settings_data+0x70>

288: ce 01 movw r24, r28

28a: 01 97 sbiw r24, 0x01 ; 1

28c: f1 f7 brne .-4 ; 0x28a <settings_data+0x68>

{

_delay_ms(200); // антидребезг

++i_0; // увеличение значения

28e: 1f 5f subi r17, 0xFF ; 255

290: 06 c0 rjmp .+12 ; 0x29e <settings_data+0x7c>

}

else if((PIND & (1<<DECREMENT))==0)

292: 81 99 sbic 0x10, 1 ; 16

294: 04 c0 rjmp .+8 ; 0x29e <settings_data+0x7c>

296: ce 01 movw r24, r28

298: 01 97 sbiw r24, 0x01 ; 1

29a: f1 f7 brne .-4 ; 0x298 <settings_data+0x76>

{

_delay_ms(200); // антидребезг

--i_0; // уменьшение значения

29c: 11 50 subi r17, 0x01 ; 1

uint8_t buffer; // промежуточный буффер данных

uint8_t rtc_data; // данные

i_0=lower; // начальное значение

buffer=0x0; // начальное значение

rtc_data=0x0; // начальное значение

while((PIND & (1<<SETTINGS))!=0)

29e: 80 99 sbic 0x10, 0 ; 16

2a0: d1 cf rjmp .-94 ; 0x244 <settings_data+0x22>

2a2: 80 e5 ldi r24, 0x50 ; 80

2a4: 93 ec ldi r25, 0xC3 ; 195

2a6: 01 97 sbiw r24, 0x01 ; 1

2a8: f1 f7 brne .-4 ; 0x2a6 <settings_data+0x84>

--i_0; // уменьшение значения

}

}

}

_delay_ms(200); // антидребезг

rtc_write_byte(address, rtc_data); // запись данных

2aa: 8c 2d mov r24, r12

2ac: 60 2f mov r22, r16

2ae: f7 de rcall .-530 ; 0x9e <rtc_write_byte>

}

2b0: df 91 pop r29

2b2: cf 91 pop r28

2b4: 1f 91 pop r17

2b6: 0f 91 pop r16

2b8: ff 90 pop r15

2ba: ef 90 pop r14

2bc: df 90 pop r13

2be: cf 90 pop r12

2c0: 08 95 ret

000002c2 <rtc_settings>:

// rtc_settings - функция установки параметров

void rtc_settings(void)

{

rtc_write_byte(CONTROL_REG, 0x80); // остановка внутреннего генератора

2c2: 8f e8 ldi r24, 0x8F ; 143

2c4: 60 e8 ldi r22, 0x80 ; 128

2c6: eb de rcall .-554 ; 0x9e <rtc_write_byte>

settings_data(31, 1, 0x84, DATE_WRITE); // установка числа месяца

2c8: 8f e1 ldi r24, 0x1F ; 31

2ca: 61 e0 ldi r22, 0x01 ; 1

2cc: 44 e8 ldi r20, 0x84 ; 132

2ce: 24 e8 ldi r18, 0x84 ; 132

2d0: a8 df rcall .-176 ; 0x222 <settings_data>

settings_data(12, 1, 0x87, MONTH_WRITE); // установка месяца

2d2: 8c e0 ldi r24, 0x0C ; 12

2d4: 61 e0 ldi r22, 0x01 ; 1

2d6: 47 e8 ldi r20, 0x87 ; 135

2d8: 25 e8 ldi r18, 0x85 ; 133

2da: a3 df rcall .-186 ; 0x222 <settings_data>

settings_data(99, 0, 0x8A, YEAR_WRITE); // установка года

2dc: 83 e6 ldi r24, 0x63 ; 99

2de: 60 e0 ldi r22, 0x00 ; 0

2e0: 4a e8 ldi r20, 0x8A ; 138

2e2: 26 e8 ldi r18, 0x86 ; 134

2e4: 9e df rcall .-196 ; 0x222 <settings_data>

settings_data(23, 0, 0xC4, HOURS_WRITE); // установка часов

2e6: 87 e1 ldi r24, 0x17 ; 23

2e8: 60 e0 ldi r22, 0x00 ; 0

2ea: 44 ec ldi r20, 0xC4 ; 196

2ec: 22 e8 ldi r18, 0x82 ; 130

2ee: 99 df rcall .-206 ; 0x222 <settings_data>

settings_data(59, 0, 0xC7, MINUTES_WRITE); // установка минут

2f0: 8b e3 ldi r24, 0x3B ; 59

2f2: 60 e0 ldi r22, 0x00 ; 0

2f4: 47 ec ldi r20, 0xC7 ; 199

2f6: 21 e8 ldi r18, 0x81 ; 129

2f8: 94 df rcall .-216 ; 0x222 <settings_data>

settings_data(59, 0, 0xCA, SECONDS_WRITE); // установка секунд

2fa: 8b e3 ldi r24, 0x3B ; 59

2fc: 60 e0 ldi r22, 0x00 ; 0

2fe: 4a ec ldi r20, 0xCA ; 202

300: 20 e8 ldi r18, 0x80 ; 128

302: 8f df rcall .-226 ; 0x222 <settings_data>

rtc_write_byte(CONTROL_REG, 0x0); // запуск внутреннего генератора

304: 8f e8 ldi r24, 0x8F ; 143

306: 60 e0 ldi r22, 0x00 ; 0

308: ca de rcall .-620 ; 0x9e <rtc_write_byte>

}

30a: 08 95 ret

0000030c <main>:

void display_write_byte(uint8_t reg, uint8_t bit, uint8_t display_data); // функция записи байта в дисплей

void display_write_strong(uint8_t display_data[], uint8_t size); // функция записи строки в дисплей

void display_write_time(void); // функция записи времени и даты в дисплей

void display_write_bcd(uint8_t display_data); // функция разделения числа BCD

int main(void)

{

30c: cf 93 push r28

30e: df 93 push r29

// настройка GPIO

DDRD=0x38; // настройка линий порта D

310: 88 e3 ldi r24, 0x38 ; 56

312: 81 bb out 0x11, r24 ; 17

DDRB=0xFE; // настройка линий порта B

314: 8e ef ldi r24, 0xFE ; 254

316: 87 bb out 0x17, r24 ; 23

PORTD=0x7; // настройка подтягивающих резисторов линий порта D

318: 87 e0 ldi r24, 0x07 ; 7

31a: 82 bb out 0x12, r24 ; 18

// основная программа

display_init(); // инициализация дисплея

31c: ef de rcall .-546 ; 0xfc <display_init>

rtc_write_byte(CONTROL_REG, 0x0); // инициализация RTC

31e: 8f e8 ldi r24, 0x8F ; 143

320: 60 e0 ldi r22, 0x00 ; 0

322: bd de rcall .-646 ; 0x9e <rtc_write_byte>

324: c0 e5 ldi r28, 0x50 ; 80

326: d3 ec ldi r29, 0xC3 ; 195

while(1)

{

display_write_time(); // запись данных о времени и дате

328: 3f df rcall .-386 ; 0x1a8 <display_write_time>

if((PIND & (1<<SETTINGS))==0)

32a: 80 99 sbic 0x10, 0 ; 16

32c: fd cf rjmp .-6 ; 0x328 <main+0x1c>

32e: ce 01 movw r24, r28

330: 01 97 sbiw r24, 0x01 ; 1

332: f1 f7 brne .-4 ; 0x330 <main+0x24>

{

_delay_ms(200); // антидребезг

rtc_settings(); // настройка параметров RTC

334: c6 df rcall .-116 ; 0x2c2 <rtc_settings>

336: f8 cf rjmp .-16 ; 0x328 <main+0x1c>

00000338 <_exit>:

338: f8 94 cli

0000033a <__stop_program>:

33a: ff cf rjmp .-2 ; 0x33a <__stop_program>