433

t_WHQX

Удержание данных после сигнала

33

Рис.10. Временная диаграмма работы микропроцессорной системы в режиме записи в ОЗУ

7. Разработка програмного обеспечения

Программное обеспечение реализовывалось по следующим алгоритмам:

и алгоритм формирования Y3 и Y2:

Листинг программы:

bseg; объявляем сегмент с побитовым доступом для флагов I2C и других

NoAck: dbit 1

BusFault: dbit 1

I2CBusy: dbit 1

X1: dbit 1

X2: dbit 1

X3: dbit 1

X4: dbit 1

dseg at 30h

sum: ds 3

N5: ds 20

N6: ds 20

N7: ds 2

Q2: ds 3

Q4: ds 2

Q0: ds 2

K: ds 1

A0: ds 2

A1: ds 1

BitCnt: ds 1; Счетчик битов для I2C

ByteCnt: ds 1; Счетчик байтов для I2C

SlvAdr: ds 1; Адрес ведомого

tout: ds 3; таймаут

XmtDat: ds 8; Буфер передачи I2C, 8 байт

RcvDat: ds 8; Буфер приема I2C, 8 байт

N equ 10

KEYB_ADDR equ 01110100b

ADC_ADDR equ 01000010b

cseg

jmp start

org 3h

jmp int1_alarm

org 13h

jmp int2_power

org 23h

jmp int3_keyb

org 40h

constQ0: dw 7FFh; константа Q0

constK: db 24; K

constA0: dw 1F4h; A0

constA1: db 4; A1

stack equ 0C8h; глубина стека от 200 до 255 байт - 55 байт

CONVST bit P1.0; сигнал запуска АЦП

HBEN bit P1.2; разрешение загрузки старшего байта в ЦАП

LDAC bit P1.3; обновление регистров ЦАП

Y1 bit P1.4; управляющий сигнал

CS1 bit P1.5; управление контроллером дисплея

CE0 bit P1.6; управление таймером КР580ВИ53

ALM bit P1.7; аварийная сигнализация

SCLpin bit P3.0; синхронизация I2C

SDApin bit P3.1; данные I2C

CE1 bit P3.4; управление таймером КР580ВИ53

WDI bit P3.5; управление сторожевым таймером

start:

mov SP,#stack-1

mov IE,#7Fh; запретим прерывания

mov P1,#10011100b

mov P3,#11000011b

setb WDI; сбросим watchdog

nop

clr WDI

; // // // // // // // // // // // // // // //

; инициализация Т2 как источника внешнего прерывания

mov 0C9h,#00000000B; перезапускаемый режим (0C9h - адрес T2MOD)

mov 0C8h,#01001000B; Режим таймера Т2. Счетчик, счет от внешнего входа (0C8h - адрес T2CON)

mov 0CDh,#0FFH; Запись значения в таймер Т2 (0CDh - адрес TH2)

mov 0CCh,#0FFH; Запись значения для 16 разрядного счета (0CCh - адрес TH2)

; // // // // // // // // // // // // // // //

; инициализируем АЦП

mov XmtDat,#00000010b; адрес РУС

mov XmtDat+1,#01010000b; управляющее слово

mov SlvAdr,#ADC_ADDR; загрузим адрес с запросом записи - последний бит "0"

mov R0,#XmtDat;

mov ByteCnt,#2;

acall SendData;

; теперь необходимо вернуть указатель на регистр результата

mov XmtDat,#00000000b; адрес регистра результата

mov SlvAdr,#01000010b; загрузим адрес с запросом записи - последний бит "0"

mov R0,#XmtDat;

mov ByteCnt,#1;

acall SendData;

; // // // // // // // // // // // // // // /

; инициализируем контроллер клавиатуры

mov XmtDat,#00000001b; адрес РУС

mov XmtDat+1,#00000000b; управляющее слово для 0х01

mov XmtDat+2,#00000000b; управляющее слово для 0х02 - автоувеличение адреса

mov XmtDat+3,#10100000b; управляющее слово для 0х03 - автоувеличение адреса

mov XmtDat+4,#10000000b; управляющее слово для 0х04 - автоувеличение адреса

mov SlvAdr,#KEYB_ADDR; загрузим адрес с запросом записи - последний бит "0"

mov R0,#XmtDat;

mov ByteCnt,#5;

acall SendData;

; теперь необходимо вернуть указатель на регистр FIFO

mov XmtDat,#00000000b; адрес регистра FIFO

mov SlvAdr,#01110100b; загрузим адрес с запросом записи - последний бит "0"

mov R0,#XmtDat;

mov ByteCnt,#1;

acall SendData;

; // // // // // // // // // // // // // // // // // /

; загрузим константы

mov DPTR,#constQ0; константа Q0

mov A,#00h; старший байт

movc A,@A+DPTR;

mov Q0,A; старший байт

mov A,#01h; младший байт

movc A,@A+DPTR

mov Q0+1,A; младший байт

mov DPTR,#constK; уставка K

mov A,#00h;

movc A,@A+DPTR;

mov K,A;

mov DPTR,#constA0; константа A0

mov A,#00h; старший байт

movc A,@A+DPTR;

mov A0,A; старший байт

mov A,#01h; младший байт

movc A,@A+DPTR

mov A0+1,A; младший байт

mov DPTR,#constA1; константа A1

mov A,#00h;

movc A,@A+DPTR;

mov A1,A

; // // // // // // // // // // // // // // // // // //

mov IE,#0BFh; разрешим прерывания

MAIN_CYCLE:

mov DPTR,#0C000h

movx A,@DPTR; введем X1 - X4

mov DPTR,#0D000h

movx @DPTR,A; выведем X1 - X4

acall CALC_Q1; посчитаем Y1

jnc no_Y1; проверяем, надо ли выводить Y1

clr Y1

acall Y1_DELAY; задержка 90 мс

setb Y1

no_Y1:

; введем Х5, Х6, Х7

setb Y1

acall AINPUT

acall CALC_Q2

acall Y2_OR_Y3

acall CALC_Q4

acall OUTP_Y4

acall IND

; DELAY

setb WDI; сбросим watchdog

nop

clr WDI

mov R7,#6

MAIN_DELAY1:

mov TMOD,#00000001b; режим таймера 0 - счетчик

mov TH0,#HIGH (65536-536)

mov TL0,#LOW (65536-536)

setb TR0; запустим таймер

MAIN_DELAY: jnb TF0,MAIN_DELAY; подождали 65 мс

clr TF0

clr TR0

djnz R7, MAIN_DELAY1

jmp MAIN_CYCLE

; // // // // // // // // // // // // // // // //

; рассчет Q1

CALC_Q1:

rrc A; введем значение X1

mov X1,C

rrc A; выдвинем второй бит и

orl C,X1; сделаем OR с первым

mov X1,C; сохраним результат

rrc A; выдвинем третий бит и

orl C,X1; сделаем OR с предыдущим

mov X1,C; сохраним результат

rrc A; выдвинем четвертый бит и

orl C,X1; сделаем OR с предыдущим

; конец, результат 0 или 1 образовался во флаге С

ret

; // // // // // // // // // // // // // // // //

; задержка для Y1

Y1_DELAY:

mov TMOD,#00000001b; режим таймера 0 - счетчик

mov TH0,#HIGH (65536-60000)

mov TL0,#LOW (65536-60000)

setb TR0; запустим таймер

Y1_DELAY_M1:

jnb TF0,Y1_DELAY_M1; подождали 60 мс, надо еще 30

clr TF0

clr TR0

mov TH0,#HIGH (65536-30000)

mov TL0,#LOW (65536-30000)

setb TR0; запустим таймер

Y1_DELAY_M2:

jnb TF0,Y1_DELAY_M2; подождали еще 30 мс

clr TF0

clr TR0

ret

; // // // // // // // // // // // // // // // // /

AINPUT:

mov DPTR,#8000h; выбор канала мультиплексора

mov A,#00h

movx @DPTR,A; выставим номер канала

nop; подождем

mov R1,#N5; адрес первого байто массива N5

mov R7,#N; в массиве 10 элементов

AINPUT_CYCLE_N5:

setb CONVST; включение АЦП

nop; ожидание перехода АЦП из спящего в нормальный режим

nop

clr CONVST; захват сигнала и запуск конвертации на АЦП

mov SlvAdr,#ADC_ADDR; загрузим адрес с запросом записи - последний бит "0"

mov R0,#RcvDat;

mov ByteCnt,#2;

acall RcvData; так как процедура чтения сама увеличивает адрес на 1, то сама сформирует адрес с запросом на чтение

dec R0

mov A,#01h

anl A,@R0; уберем из старшего байта старшие 4 бита

mov @R1,A; запишем старший байт элемента массива N5

inc R0; адрес младшего байта из АЦП

inc R1; адрес следующего байта массива N5

mov A,@R0; младший байт из АЦП

mov @R1,A; младший байт элемента массива N5

inc R1; адрес следующего элемента массива N5

djnz R7,AINPUT_CYCLE_N5

mov R1,#N6

mov R7,#N

mov DPTR,#8001h; выбор канала мультиплексора

mov A,#00h

movx @DPTR,A; выставим номер канала

nop; подождем

AINPUT_CYCLE_N6:

setb CONVST; включение АЦП

nop; ожидание перехода АЦП из спящего в нормальный режим

nop

clr CONVST; захват сигнала и запуск конвертации на АЦП

mov SlvAdr,#ADC_ADDR; загрузим адрес с запросом записи - последний бит "0"

mov R0,#RcvDat;

mov ByteCnt,#2;

acall RcvData; так как процедура чтения сама увеличивает адрес на 1, то сама сформирует адрес с запросом на чтение

dec R0

mov A,#01h

anl A,@R0; уберем из старшего байта старшие 4 бита

mov @R1,A; запишем старший байт элемента массива N5

inc R0; адрес младшего байта из АЦП

inc R1; адрес следующего байта массива N5

mov A,@R0; младший байт из АЦП

mov @R1,A; младший байт элемента массива N5

inc R1; адрес следующего элемента массива N5

djnz R7,AINPUT_CYCLE_N6

mov DPTR,#8002h; выбор канала мультиплексора

mov A,#00h

movx @DPTR,A; выставим номер канала

nop; подождем

setb CONVST; включение АЦП

nop; ожидание перехода АЦП из спящего в нормальный режим

nop

clr CONVST; захват сигнала и запуск конвертации на АЦП

mov SlvAdr,#ADC_ADDR; загрузим адрес с запросом записи - последний бит "0"

mov R0,#RcvDat;

mov ByteCnt,#2;

acall RcvData; так как процедура чтения сама увеличивает адрес на 1, то сама сформирует адрес с запросом на чтение

dec R0

mov A,#01h

anl A,@R0; уберем из старшего байта старшие 4 бита

mov R1,#N7; адрес N7

mov @R1,A; запишем старший байт N7

inc R0

inc R1

mov A,@R0; младший байт из АЦП

mov @R1,A; запишем младший байт N7

ret

; // // // // // // // // // // // // // // // // // // //

CALC_Q2:

mov R7,#N; записываем счетчик элементов в массиве Q2

mov R0,#N5; начальный адрес массива N5

mov R1,#N6; начальный адрес массива N6

mov sum+2,#00h; обнуляем старший байт суммы Qi

mov Q2+2,#00h; обнуляем старший байт суммы массива Q2

CALC_Q2_cycle:

mov sum,#00h; обнуление буфера промежуточных сумм

mov sum+1,#00h;

mov sum+2,#00h;

mov A,@R0; получение старшего байта

rrc A; сдвиг вправо старшего байта элемента массива N5

mov R5,A; запись старшего байта элемента массива N5 в R1

inc R0; увеличение адреса для доступа к младшему байту массива N5

mov A,@R0; получение младшего байта элемента массива N5

rrc A; сдвиг вправо младшего байта массива N5, в результате имеем

mov R4,A; поделенный на 2 элемент массива N5

clr C;

inc R0; увеличение индекса для доступа к след. элементам массива

mov A,@R1; получение старшего байта элемента массива N6

mov R3,A; запись старшего байта элемента массива N6 в R3

inc R1; увеличение адреса для доступа к младшему байту массива N6

mov A,@R1; получение младшего байта элемента массива N6

mov R2,A; запись младшего байта элемента массива N6 в R2

inc R1; увеличение индекса для доступа к след. элементам массива

; подсуммирование К

mov A,R4; младший байт N5/2

add A,#K; подсуммирование К

mov R4,A;

mov A,R5; старший байт N5/2

addc A,#0; учет переполнения

mov R5,A;

mov A,R4; младший байт N5/2

add A,R2; сложение с младшим байтом N6

mov sum,A; запись младшего байта промежуточной суммы

mov A,R5; старший байт N5/2

addc A,R3; сложение со старшим байтом N6

mov sum+1,A; запись среднего байта промежуточной суммы

jnc CALC_Q2_m11;

inc sum+2; учет переполнения

CALC_Q2_m11:;

mov A,R0

push ACC

mov A,R1

push ACC

; сложение Q и текущей суммы элементов

mov R0,#Q2; адрес Q2

mov R1,#sum; адрес sum

mov R3,#3; количество байтов Q2

clr C;

CALC_Q2_addm:;

mov A,@R0; запись байта Q2

addc A,@R1; сложение с байтом sum

mov @R0,A; запоминание байто суммы

inc R0; адрес следующего байта Q2

inc R1; адрес следующего байта sum

djnz R3,CALC_Q2_addm; счет количества байтов

pop ACC

mov R1,ACC

pop ACC

mov R0,ACC

djnz R7,CALC_Q2_cycle; счет количества элементов массива

; деление суммы Q2 на N

mov R4,Q2+2; старший байт суммы Q2

mov R3,Q2+1; средний байт суммы Q2

mov R2,Q2; младший байт суммы Q2

mov R0,#N; делитель

mov A,R4; старший байт суммы Q2

mov B,R0; делитель

div AB;

mov R4,A; получение старшего байта частного

mov R5,B; текущий остаток

;

mov B,R0; делитель

mov R1,#16; количетво разрядов делимого

CALC_Q2_dwb3:;

clr C;

mov A,R2;

rlc A; сдвиг влево младших разрядов частного

mov R2,A;

mov A,R3;

rlc A; сдвиг влево старших разрядов частного

mov R3,A;

mov A,R5;

rlc A; сдвиг влево текущего остатка

cjne A,B,CALC_Q2_dwb1; сравнение текущего остатка с делителем

CALC_Q2_dwb1:;

jc CALC_Q2_dwb2; переход, если остаток меньше делителя

subb A,B; вычитание делителя из текущего остатка

inc R2; запись 1 в очередной разряд частного

CALC_Q2_dwb2:;

mov R5,A; сохранение остатка

djnz R1,CALC_Q2_dwb3; повторить 16 раз

mov Q2+2,R2; запишем младший байт суммы Q2

mov Q2+1,R3; запишем средний байт суммы Q2

mov Q2,R4; запишем старший байт суммы Q2

ret

; // // // // // // // // // // // // // // // /

Y2_OR_Y3:

; сравним вычитанием Q2-Q0

clr C; Вычитание осуществляем с заемом.

mov A,Q2+2; младший байт Q2

subb A,Q0+1; вычитаем младший байт Q0

mov A,Q2+1; средний байт Q2

subb A,Q0; вычитаем старший байт Q0

mov A,Q2; старший байт Q2

subb A,0; проверка, был ли заем

mov C,ACC.7; по результам вычитания анализируем получившееся значение на знак.

jc CREATE_Y2; если C=1 (Q2<Q0), переход на метку

CREATE_Y3:; если Q2>Q0, формируем Y3

mov DPTR,#0A003h; запись управляющего слова в РУС канала 2

mov A,#10110110b; канал 2, тип - двоичный счетчик, режим 3 (делитель частоты), режим загрузки младший, затем старший

movx @DPTR,A; выведем слово

nop

mov DPTR,#0A002h; загрузим канал 2

mov A,#0F4h; данные для загрузки - младший байт (для периода 1 мс при периоде CLК 2 мкс загрузим 500 или 1F4h)

movx @DPTR,A; выведем данные

nop

mov A,#01h; старший байт

movx @DPTR,A; выведем данные

nop

mov DPTR,#0A003h; запись управляющего слова в РУС канала 1

mov A,#01110010b; канал 1, тип - двоичный счетчик, режим 1 (ждущий мультивибратор), режим загрузки младший, затем старший

movx @DPTR,A; выведем данные

nop

mov DPTR,#0A001h; загрузим канал 1

mov A,#30h; данные для загрузки - младший байт (для формирования импульса разрешения счета каналу 2 на 60 мс, при периоде CLK 2 мкс загрузим 30000 или 7530h)

movx @DPTR,A; выведем данные

nop

mov A,#75h; старший байт

movx @DPTR,A; выведем данные

nop

setb CE1; разрешим счет каналу 1

nop

clr CE1

ret

CREATE_Y2:

mov DPTR,#0A003h; запись управляющего слова в РУС канала 0

mov A,#00110010B; канал 0, тип - двоичный счетчик, режим 1 (ждущий мультивибратор), режим загрузки младший, затем старший

movx @DPTR,A; выведем слово

nop; подождем

mov DPTR,#0A000h; загрузка канала 0

mov A,#98h; данные для загрузки - младший байт (для 30 мс при периоде 2 мкс загрузим 15000 или 3А98h)

movx @DPTR,A; выведем данные

mov A,#0H; старший байт

movx @DPTR,A; выведем данные

setb CE0

nop

clr CE0

ret

; // // // // // // // // // // // // // // // /

CALC_Q4:

mov A,Q4

clr C

mov A,N7; получение старшего байта N7

rrc A; сдвиг вправо старшего байта N7

mov R3,A; запись старшего байта N7 в R3

mov A,N7+1; получение младшего байта N7

rrc A; сдвиг вправо младшего байта массива N5, в результате имеем

mov R2,A; поделенный на 2 элемент N7

clr C

mov A,R3; получение старшего байта N7

rrc A; сдвиг вправо старшего байта N7

mov R3,A; запись старшего байта N7 в R3

mov A,R2; получение младшего байта N7

rrc A; сдвиг вправо младшего байта массива N5, в результате имеем

mov R2,A; поделенный на 2 элемент N7

; поделили, теперь прибавим А0

clr C

mov A,R2; младший байт N7

add A,A0; подсуммирование К

mov R2,A;

mov A,R3; старший байт N7

addc A,A0+1;

mov R3,A;

mov Q4+1,R2; запишем Q4

mov Q4,R3

ret

; // // // // // // // // // // // // // // // /

OUTP_Y4:

mov DPTR,#9000h; адрес ЦАП

mov A,Q4+1; младший байт Q4

movx @DPTR,A; выведем

nop; подожем

setb HBEN; разрешение загрузки старшего байта

mov A,Q4; старший байт

movx @DPTR,A; вывод

nop

clr HBEN; сбросим HBEN

clr LDAC; обновим регистр ЦАП

nop

setb LDAC; сбросим LDAC

ret

; // // // // // // // // // // // // // // // /

IND:

mov R3,Q4; старший байт 4

mov R2,Q4+1; младший байт

mov R0,#10; делитель

mov R7,#4; 4 знакоместа

mov DPTR,#0B000h; выберем первое знакоместо

IND_CYCLE:

call DIV_LED

movx @DPTR,A; выведем очередной разряд Q4

setb CS1; запишем в контроллер

nop

clr CS1

inc DPTR

djnz R7, IND_CYCLE

ret

; // // // // // // // // // // // // // // // /

DIV_LED:; в R3, R2 делимое и результат, в R0 делитель, в А - остаток.

mov A,R3; старший байт делимого

mov B,R0; делитель

div AB

mov R3,A; старший байт частного

mov A,B; текущий остаток

mov B,R0; делитель

mov R1,#8; количество разрядов остатка

DIV_LED_dwb3:

clr C; очистим С

xch A,R2

rlc A; сдвиг младших частного

xch A,R2

rlc A; сдвиг остатка

cjne A,B,DIV_LED_dwb1; сравнение остатка с делителем

DIV_LED_dwb1:

jc DIV_LED_dwb2; переход, если остаток меньше делителя

subb A,B; вычитание делителя из текущего остатка

inc R2; запись 1 в очередной разряд частного

DIV_LED_dwb2:

djnz R1,DIV_LED_dwb3; повторить 8 раз

ret

; // // // // // // // // // // // // // // // // // // // // //

ALM_DELAY:

mov R7,#0C7h; задержка примерно на 1 мс

ALM_DELAY1:

nop

nop

nop

djnz R7,ALM_DELAY1

RET

ret

; // // // // // // // /прерывания // // // // // // // // // /

int1_alarm:

mov DPTR,#0C000h

movx A,@DPTR; введем X1 - X4

mov DPTR,#0D000h

movx @DPTR,A; выведем X1 - X4

call IND

INT1_LOOP:

setb ALM; звуковая сигнализация 500 Гц

acall ALM_DELAY;

clr ALM

acall ALM_DELAY

jmp INT1_LOOP

reti

; // // // // // // // // // // // // // // // // // /

int2_power:

mov DPTR,#1000h

mov A,#0FFh

movx @DPTR,A

mov R0, #0FFh

INT2_LOOP:

inc DPTR

mov A,@R0

movx @DPTR,A

djnz R0, INT2_LOOP

reti

; // // // // // // // // // // // // // // // // // // // // // /

int3_keyb:

; не реализовано, т.к. не указано в задании

reti

; // // // // // /прерывания закончились // // // // // // // // // //

; Процедуры для работы с I2С

BitDly:; задержка на 5 мкс (2 на call, 2 на ret, 1 на nop)

nop

ret

; // // // // // // // // // // // // // // // // /

SCLHigh:; установка SCL в 1

setb SCLPin; установить

jnb SCLPin,$; подождать, пока не установится в 1

ret

; // // // // // // // // // // // // // // // // // /

SendStop:; посылка stop условия и освобождение шины

clr SDAPin; установка SDA в 0

call SCLHigh; установка SCL в 1

call BitDly; задержка

setb SDAPin; посылка stop условия

call BitDly; задержка

clr I2CBusy; шина свободна

ret

; // // // // // // // // // // // // // // // // //

SendByte:; процедура посылки байта, байт для посылки в Асс

mov BitCnt,#8; Set bit count.

SBLoop:

rlc A; выдвинем 1 бит в С

mov SDAPin,C; выставим бит на шине

call SCLHigh; импульс синхронизации

call BitDly; задержка

clr SCLPin; конец импульса

call BitDly

djnz BitCnt,SBloop; повторить для 8 бит

setb SDAPin; освободим линию для приема подтвержения

call SCLHigh; SCL для подтверждения

call BitDly

jnb SDAPin,SBEX; получено ли подтверждение

setb NoAck; если не получено, фиксируем

SBEX:

clr SCLPin; завершение приема подтверждения

call BitDly

ret

; // // // // // // // // // // // // // // // // // // //

GoMaster:; процедура посылки старт-условия и адреса ведомого I2C устройства

; адрес ведомого в переменной SlvAdr

setb I2CBusy; займем шину

clr NoAck; очистим флаг подтверждения

clr BusFault; и флаг ошибки

jnb SCLPin,Fault; проверка, свободна ли шина

jnb SDAPin,Fault

clr SDAPin; начало посылки старт-условия (SCL в 1, SDA 1->0)

call BitDly; задержка

clr SCLPin; сброс SCL

call BitDly; завершение старт процедуры

mov A,SlvAdr; получим адрес ведомого и

call SendByte; пошлем его в шину

ret

Fault:

setb BusFault; если ошибка, то установить флаг

ret; и выйти

; // // // // // // // // // // // // // // // // // // // // /

SendData:; процедура посылки данных (мах 8 байт) в I2C устройство

; в переменной ByteCnt сколько байт послать

; в переменной SlvAdr адрес ведомого

; в регистре R0 адрес буфера с данными

call GoMaster; занимаем шину и посылаем адрес

jb NoAck,SDEX; если ведомый не отвечает, то ошибка

SDLoop:

mov A,@R0; получим очередной байт из буфера

call SendByte; пошлем его в шину

inc R0; перейдем к следующему байту

jb NoAck,SDEX; если была ошибка, выходим

djnz ByteCnt,SDLoop; повторить до конца буфера

SDEX:

call SendStop; передача закончена, посылка стоп-условия и освобождение шины

ret

; // // // // // // // // // // // // // // // // //

RcvByte:; прием байта от I2C устройства

; в Асс принятый байт

mov BitCnt,#8; счетчик бит

RBLoop:

call SCLHigh; прочитаем очередной бит

call BitDly

mov C,SDAPin; перепишем в С

rlc A; перепишем бит в А

clr SCLPin; очистим SCL

call BitDly

djnz BitCnt,RBLoop; повторим для 8 бит

push Acc; сохраним Асс

mov A,ByteCnt;

cjne A,#1,RBAck; проверим, последний байт или нет

setb SDAPin; на последний байт подтверждение не выдаем

sjmp RBAClk; и переходим сразу к выдаче SCL

RBAck:

clr SDAPin; выдаем подтверждение на непоследний байт

RBAClk:

call SCLHigh; CLK для подтверждения

pop Acc; восстановим А

call BitDly; задержка

clr SCLPin

setb SDAPin; очистим SDA

call BitDly

ret

; // // // // // // // // // // // // // // // // // // // // // //

RcvData:; процедура приема байтов (мах 8) от ведомого I2C устройства

; в переменной ByteCnt сколько байт принять

; в переменной SlvAdr адрес ведомого

; в регистре R0 адрес буфера для данных

inc SlvAdr; формирование адреса ведомого с запросом на чтение

call GoMaster; посылка адреса

jb NoAck,RDEX; проверка, ответил ли ведомый

RDLoop:

call RcvByte; принимаем байт

mov @R0,A; сохраняем его

inc R0; переходим к следующему адресу буфера

djnz ByteCnt,RDLoop; повторим для всех байт

RDEX:

call SendStop; послать стоп-условие и освободить шину

ret

; // // // // // // // // // // // // // // // // // // // // // //

end.

Заключение

В результате проектирования была создана микропроцессорная система для управления объектом.

Основные характеристики:

Используется микроконтроллер AT89С52;

В МПС имеется память двух типов: ПЗУ емкостью 8 Кбайт и ОЗУ емкостью 8 Кбайт;

Для ввода используется клавиатура, состоящая из 25 клавиш;

Для вывода используются светодиодные индикаторы, кроме того, имеется световая аварийная сигнализация;

МПС принимает информацию в виде 3 аналоговых и 6 двоичных сигналов, из которых 2 являются сигналами от датчиков аварийных ситуаций;

МПС выдает информацию в виде 1 аналогового и 3 двоичных сигналов.

Возможно расширение управляющих алгоритмов МПС. Также имеются возможности по расширению аппаратной конфигурации: в системе остался один незадействованный аналоговый вход, шесть клавиш, не имеющих функциональной нагрузки.

Основными результатами проектирования являются принципиальная электрическая схема МПС и программа, реализующая управляющие алгоритмы МПС.

Приложение. Спецификация используемых элементов

№	обозначение	Наименование	Кол-во	Примечание
Микросхемы:
1	DD1	КР1533ЛЛ1	1
2	DD2	AT89C52	1	Atmel
3	DD3	КР1533ЛИ1	1
4	DD4,DD18	КР1533ЛН2	2
5	DD5	DG409	1	Analog Devices
6	DD6	AD7992	1	Analog Devices
7	DD7, DD8, DD16	КР1533ИР22	3
8	DD9	КР1533ИД7	1
9	DD10	AD5341	1	Analog Devices
10	DD11	К573РФ6А	1
11	DD12	КР580ВИ53	1
12	DD13	КР1810ГФ84	1
13	DD14	DS1225AB	1	Maxim
14	DD15	ICM7212	1	Maxim
15	DD17	MAX7347	1	Maxim
16	DA1	ADR540B	1	Analog Devices
17	DA2	MAX6317H	1	Maxim
18	DA3	LM317	1	ON Semiconductor
Резисторы:
18	R1, R19, R20	C1-4-0.25-1 кОм 5%	3
19	R2, R3,R21	C1-4-0.25-100 кОм 5%	3
20	R5	C1-4-0.25-24 кОм5%	1

№	обозначение	Наименование	Кол-во	Примечание
21	R8	C1-4-0.25-330 Ом5%	1
22	R9	C1-4-0.25-240 Ом5%	1
23	R10	C1-4-0.25-100 Ом5%	1
24	R12. R15	C1-4-0.25-360 Ом5%	4
25	R16	C1-4-0.25-33 Ом5%	1
26	R17	C1-4-0.25-430 Ом5%	1
27	R18	C1-4-0.25-1,5 кОм5%	1
Конденсаторы:
28	С1, C2	X7R NPO 30 пФ ± 20%	2
29	С3, C4, C6, C13	K10-17 0.1 мкФ - 20% +80%	4
30	С5,C7	К53 - 18 - 16В - 10мкФ +50% - 20%	2
31	С8	X7R NPO 20 пФ - 20% +80%	1
32	С9, C14	К53 - 18 - 16В - 20мкФ +50% - 20%	2
33	C16	К10-17 1мкф - 20% +80%	1
34	С10, C11, C12, C15	К10-17 0,1 мкФ - 20% +80%	4
Светодиоды:
35	VD1. VD4	АЛ102А	4
36	HG1-HG4	SA56 - 11SRWA	4	KingBright
Резонаторы:
37	ZQ1	ZTA - 12 МГц, кварцевый	1
38	ZQ2	ZTA - 500 кГц, керамический	1
Кнопки:
39	K0. K24	DTS-24N, (SWT-9) кнопка тактовая	25

№	обозначение	Наименование	Кол-во	Примечание
Пьезоголовки:
40	ВА1	0.25ГДШ2	1
Транзисторы
41	VT1	КТ501Б	1

Размещено на Allbest.ru