Программная реализация кодера и декодера БЧХ-кода (63,36), исправляющего ошибки кратности пять, для микроконтроллера МК51

Размещено на http://www.allbest.ru/

Программная реализация кодера и декодера БЧХ-кода (63,36), исправляющего ошибки кратности пять, для микроконтроллера МК51

кодер циклический ошибка микроконтроллер



1. Кодер БЧХ

Для кодирования исходного сообщения в БЧХ-код (63,36) был выбран табличный полином, представление которого в 16-тиричной системе записывается

G(x) = 0x86E8113 (hex)

На рис.1 приведен алгоритм кодирования исходного сообщения в БЧХ код с использованием данного полинома. В тексте программы «БЧХ-кодера» описаны регистры, которые заносятся входные и выходные значения. В тексте программы описаны регистры, которые заносятся входные и выходные значения.

Размещено на http://www.allbest.ru/

Рис. 1. Алгоритм кодирования входного сообщения 36 бит в БЧХ-код

Программа для кодирования 36_бит сообщения в БЧХ-код

Программа для кодировании 36_бит сообщения циклическим; кодом - БЧХ кодом (63,36). Проверочный полином представлен

G(x) = 1033500423 (mod8) или G(x) = 0x86E8113(hex)

Кодировка происходит методом сдвига исходного кода на 27 позиций

Остаток от деления этого кода на заданный полином суммируется с исходным сдвинутым кодом, получая кодированное 63-бит сообщение в БЧХ-коде

Исходное сообщение записывается в регистрах bufer0 -bufer4 (первые 36-бит)

Выходное сообщение представляется в регистрах bufer0 - bufer7, а именно в первых 63-бит

bufer7 equ 20h

bufer6 equ 21h

bufer5 equ 22h

bufer4 equ 23h

bufer3 equ 24h

bufer2 equ 25h

bufer1 equ 26h

bufer0 equ 27h

temp3 equ 28h

temp2 equ 29h

temp1 equ 2ah

temp0 equ 2bh

count_bitCh equ 38h; счетчик разрядности числителя

count_bitZn equ 39h; счетчик разрядности знаменателя

count_takt equ 3ah; счетчик количества тактов для деления

temp_reg1 equ 3bh; регистр временных данных 1

temp_reg2 equ 3ch; регистр временных данных 2

Константы

polynom set 86e8113h; значение задающего полинома

Chislitel_bit set 64; разрядность числителя

Znamenatel_bit set 32; разрядность знаменателя

org 0; начало исполняемого кода программы.

sjmp START

Инициализация системных ресурсов микроконтроллера START: mov SP,#50h; стека по адресу 0х50; запись значения полинома в регистры temp3 - temp0

mov temp3,#high(polynom/10000h)

mov temp2,#low(polynom/10000h)

mov temp1,#high(polynom)

mov temp0,#low(polynom)

запись значения числителя в регистры bufer7 - bufer0

mov bufer7,#00h

mov bufer6,#00h

mov bufer5,#00h

mov bufer4,#08h

mov bufer3,#00h

mov bufer2,#00h

mov bufer1,#00h

mov bufer0,#00h

сдвиг влево исходного сообщения на 27 позиций



mov count_takt,#27

shift_left: acall shift_left_chislitel

djnz count_takt, shift_left

сохраним значение сдвинутого сообщения в стеке

push bufer0

push bufer1

push bufer2

push bufer3

push bufer4

push bufer5

push bufer6

push bufer7

----------------------------------------------------------------;

сохранение исходного сообщения в стеке acall DIV64_32mod2

извлечение исходного сообщения из стека

pop bufer7

pop bufer6

pop bufer5

pop bufer4

pop bufer3

pop bufer2

pop bufer1

pop bufer0

добавить остаток к подготовленному исходному сообщению

mov a,temp0

orl bufer0,a

mov a,temp1

orl bufer1,a

mov a,temp2

orl bufer2,a

mov a,temp3

orl bufer3,a

исходное сообщение закодировано, зациклить программу sjmp $

подпрограмма вычисления остатка от деления 64-х битового числителя на 32-х битовый знаменатель. Числитель должен быть записан предварительно в регистры bufer7 - bufer0 , а знаменатель в temp3 - temp0.

остаток от деления возвращается в регистрах temp3 - temp0 DIV64_32mod2:

вычисление разрядности числителя максимальное значение 64 - бита и выравнивание по старшему биту bufer 7,7

mov count_bitCh,#Chislitel_bit

count_bit_chislitel: jb bufer7.7, bits_chislitel_succefull

acall shift_left_chislitel

djnz count_bitCh, count_bit_chislitel

ajmp error; значение числителя равно нулю

shift_left_chislitel: clr c; подпрограмма сдвига 8-ми регистров в лево

mov a,bufer0

rlc a

mov bufer0,a

mov a,bufer1

rlc a

mov bufer1,a

mov a,bufer2

rlc a

mov bufer2,a

mov a,bufer3

rlc a

mov bufer3,a

mov a,bufer4

rlc a

mov bufer4,a

mov a,bufer5

rlc a

mov bufer5,a

mov a,bufer6

rlc a

mov bufer6,a

mov a,bufer7

rlc a

mov bufer7,a

ret; сдвиг влево на 1 такт выполнен

bits_chislitel_succefull:

вычисление разрядности знаменателя максимальное значение 32-бита и выравнивание по старшему биту temp3,7

mov count_bitZn,#Znamenatel_bit

count_bit_znamenatel: jb temp3.7,bits_znamenatel_succefull

clr c

mov a,temp0

rlc a

mov temp0,a

mov a,temp1

rlc a

mov temp1,a

mov a,temp2

rlc a

mov temp2,a

mov a,temp3

rlc a

mov temp3,a

djnz count_bitZn, count_bit_znamenatel

зациклиться, если неверное значение числителя или знаменателя error: sjmp $; значение числителя или знаменателя равно нулю

bits_znamenatel_succefull:

определение числа тактов деления:

(разрядность Числителя - разрядность Знаменателя)+1 результат в регистре разрядности числителя count_takt

clr C

mov a, count_bitCh

subb a,count_bitZn

jnc m2

cpl a

inc a

m2: mov count_takt,a

inc count_takt

деление числителя на знаменатель по модулю два

diviation: jnb buffer 7.7, shift_chsl

mov a,temp3

xrl bufer7,a

mov a,temp2

xrl bufer6,a

mov a,temp1

xrl bufer5,a

mov a,temp0

xrl bufer4,a

shift_chsl:acall shift_left_chislitel

djnz count_takt,diviation

вычисление числа сдвигов остатка для получения корректного результата

вычисление числа сдвигов знаменателя

mov a,#Znamenatel_bit

clr c

subb a, count_bitZn

mov count_bitZn,a

сдвиг остатка вправо на количество тактов равное полученному значению +1 числа тактов сдвига знаменателя

mov a, count_bitZn

inc a

mov count_bitCh,a

shft_rgt_ostk: clr c

mov a,bufer7

rrc a

mov bufer7,a

mov a,bufer6

rrc a

mov bufer6,a

mov a,bufer5

rrc a

mov bufer5,a

mov a,bufer4

rrc a

mov bufer4,a

djnz count_bitCh, shft_rgt_ostk

mov temp3,bufer7

mov temp2,bufer6

mov temp1,bufer5

mov temp0,bufer4

завершение операции поиска остатка от деления по модулю 2

ret

2. Декодер БЧХ

Декодер БЧХ кода работает следующим образом:

- Программа выполняет деление входного сообщения на заданный полином. Остаток от деления определяет наличие ошибки в этом сообщении.

- В таблицах остатков находятся значения остатков, определяющие положение корректирующего бита (вектора ошибки). Например, если остаток равен значению байтов в таблице ostatok_01 = 00h, 00h, 00h, 01h (здесь первый байт старший), значит, ошибка содержится в нулевом бите исходного сообщения. Если остаток, например равен значению в таблице ostatok_63 = 04h, 37h, 40h, 89h (здесь первый байт старший), значит неверный последний 63-й бит сообщения.

- Если в сообщении несколько ошибок, а данный код способен исправлять 5 ошибок, то остаток от деления будет равен сумме значений по модулю 2 байтов тех таблиц, которые указывают на ошибочные байты. Например: если в нулевом и 63-м бите ошибка, то остаток от деления будет равен сумме по модулю 2 таблиц ostatok_01 и ostatok_63.

- Таким образом, для определения ошибок программа сначала сравнивает каждую таблицу с остатком, таким образом, делая проверку 1 из 63 - одиночная проверка.

- Слаживая поочередно таблицы по две, по три, по четыре и наконец по пять таблиц, перебирая все возможные варианты находя вектор ошибки, сложение которого по модулю 2 исправляет ошибки в исходном сообщении. Если все варианты были просчитаны, а совпадения остатка с подготовленным значением путем модификации таблиц не было, значит ошибка была обнаружена, но не исправлена.

Всего возможных вариантов модификаций таблиц равняется:

Кратность ошибки	Количество итераций обработки
I	63
II	1953
III	39711
IV	595665
V	7028847
всего	7666239

Программа для декодирования 63_бит сообщения в БЧХ-коде

Программа проверки и исправления ошибок в сообщении, которое закодировано кодом циклическим БЧХ-кодом (63, 36). Проверочный полином представлен

G(x) = 1033500423(mod8) или G(x) = 0x86E8113(hex).



Размещено на http://www.allbest.ru/

Рис. 2. Алгоритм декодирования входного сообщения 63 бит в БЧХ-коде

Исходное кодовое сообщение 63 бита, предварительно закодированное кодом БЧХ полиномом G(x) = 0x86E8113(hex), записывается в регистры bufer0 - bufer7.

Регистры temp0 - temp7 содержат значение заданного полинома. Программа определяет наличие ошибки при наличии ненулевого остатка при делении исходного кодового сообщения 63 бита на заданный полином. Программа исправляет до пяти ошибок включительно. Исправленное значение заносится в регистры er_vector0 - er_vector7,а в порты Р0-Р3 значение первых четырех байт исправленного сообщения. Если ошибка была обнаружена но после обработки не была исправлена то в порты Р0 - Р3 записываются все нули

Если исходное сообщение было корректное, то значение исходного сообщения; записывается в регистры byte 0-byte 7. После отработки каждого события определения двойной ошибки(2-й подвектор)

reg_err27 equ 10h

reg_err26 equ 11h

reg_err25 equ 12h

reg_err24 equ 13h

reg_err23 equ 14h

reg_err22 equ 15h

reg_err21 equ 16h

reg_err20 equ 17h

дополнительные регистры для определения тройной ошибки (3-й подвектор)

регистры для ввода исходного сообщения для проверки

bufer7 equ 20h

bufer6 equ 21h

bufer5 equ 22h

bufer4 equ 23h

bufer3 equ 24h

bufer2 equ 25h

bufer1 equ 26h

bufer0 equ 27h

регистры содержащие значения контрольного полинома

temp3 equ 28h

temp2 equ 29h

temp1 equ 2ah

temp0 equ 2bh

байты контроля совпадения остатков

cntrl_byte3 equ 2ch

cntrl_byte2 equ 2dh

cntrl_byte1 equ 2eh

cntrl_byte0 equ 2fh

байты вектора ошибки (1-й подвектор)

er_byte7 equ 30h

er_byte6 equ 31h

er_byte5 equ 32h

er_byte4 equ 33h

er_byte3 equ 34h

er_byte2 equ 35h

er_byte1 equ 36h

er_byte0 equ 37h

count_bitCh equ 38h; счетчик разрядности числителя

count_bitZn equ 39h; счетчик разрядности знаменателя

count_takt equ 3ah; счетчик количества тактов для деления

temp_reg1 equ 3bh; регистр временных данных 1

temp_reg2 equ 3ch; регистр временных данных 2

qu 40h

reg_err46 equ 41h

reg_err45 equ 42h

reg_err44 equ 43h

reg_err43 equ 44h

reg_err42 equ 45h

reg_err41 equ 46h

reg_err40 equ 47h

дополнительные регистры для определения пятикратной ошибки (5-й подвектор)

reg_err57 equ 48h

reg_err56 equ 49h

reg_err55 equ 4ah

reg_err54 equ 4bh

reg_err53 equ 4ch

reg_err52 equ 4dh

reg_err51 equ 4eh

reg_err50 equ 4fh

регистры для хранения шумового вектора ошибок

er_vector7 equ 50h

er_vector6 equ 51h

er_vector5 equ 52h

er_vector4 equ 53h

er_vector3 equ 54h

er_vector2 equ 55h

er_vector1 equ 56h

er_vector0 equ 57h



Константы

polynom set 86e8113h; значение задающего полинома

Chislitel_bit set 64; разрядность числителя

Znamenatel_bit set 32; разрядность знаменателя

org 0; начало исполняемого кода программы.

sjmp START

Инициализация системных ресурсов микроконтроллера START: mov SP,#58h; стека по адресу 0х58

mov psw,#0

запись значения полинома в регистры temp3 - temp0

mov temp3,#high(polynom/10000h)

mov temp2,#low(polynom/10000h)

mov temp1,#high(polynom)

mov temp0,#low(polynom)

запись пользователем значения числителя в регистры bufer7 - bufer0

mov bufer7,#1ch;60h

mov bufer6,#00h;00h

mov bufer5,#00h;00h

mov bufer4,#00h;00h

mov bufer3,#02h;02h

mov bufer2,#1bh;1bh

mov bufer1,#0a0h;a0h

mov bufer0,#44h;44h

сохранение исходного сообщения в стеке

push bufer0

push bufer1

push bufer2

push bufer3

push bufer4

push bufer5

push bufer6

push bufer7

acall DIV64_32mod2

извлечение исходного сообщения из стека

pop bufer7

pop bufer6

pop bufer5

pop bufer4

pop bufer3

pop bufer2

pop bufer1

pop bufer0

проверка равен ли остаток нулю

clr a

orl a,temp3

orl a,temp2

orl a,temp1

orl a,temp0

jz NO_ERROR; переход на NO_ERROR если нет ошибок

ajmp DETECT_ERROR; переход на отработку ошибок



если не было ошибки вывести исходное значение в регистры byte0 - byte 7

NO_ERROR: mov R0,#bufer0; копируем побайтно регистры

mov R1,#byte0; bufer0 - bufer7 в регистры

acall save_r0_to_r1; byte0 - byte07 соответственно

sjmp $; зациклиться

подпрограмма вычисления остатка от деления 64-х битового числителя на 32-х битовый знаменатель. Числитель должен быть записан предварительно в регистры bufer7 - bufer0 , а знаменатель в temp3 - temp0.

остаток от деления возвращается в регистрах temp3 - temp0 DIV64_32mod2:

вычисление разрядности числителя максимальное значение 64 - бита и выравнивание по старшему биту bufer7,7

mov count_bitCh,#Chislitel_bit

count_bit_chislitel: jb bufer7.7,bits_chislitel_succefull

mov R0,#bufer0

acall shift_left8

djnz count_bitCh, count_bit_chislitel

ajmp error; значение числителя равно нулю

bits_chislitel_succefull:

вычисление разрядности знаменателя максимальное значение 32-бита; и выравнивание по старшему биту temp 3,7

mov count_bitZn,#Znamenatel_bit

count_bit_znamenatel: jb temp3.7, bits_znamenatel_succefull

clr c

mov a,temp0

rlc a

mov temp0,a

mov a,temp1

rlc a

mov temp1,a

mov a,temp2

rlc a

mov temp2,a

mov a,temp3

rlc a

mov temp3,a

djnz count_bitZn, count_bit_znamenatel

переход на отображение невозможности исправления ошибок значение числителя или знаменателя равно нулю и т.д.

error: ajmp error_not_detect

bits_znamenatel_succefull:

определение числа тактов деления:

(разрядность Числителя - разрядность Знаменателя)+1

результат в регистре разрядности числителя count_takt

clr C

mov a, count_bitCh

subb a,count_bitZn

jc error

mov count_takt,a

inc count_takt

деление числителя на знаменатель по модулю два

diviation: jnb bufer7.7, shift_chsl

mov a,temp3

xrl bufer7,a

mov a,temp2

xrl bufer6,a

mov a,temp1

xrl bufer5,a

mov a,temp0

xrl bufer4,a

shift_chsl:mov R0,#bufer0

acall shift_left8

djnz count_takt,diviation

вычисление числа сдвигов остатка для получения корректного результата вычисление числа сдвигов знаменателя

mov a,#Znamenatel_bit

clr c

subb a, count_bitZn

mov count_bitZn,a

сдвиг остатка вправо на количество тактов равное полученному значению +1; числа тактов сдвига знаменателя

mov a, count_bitZn

inc a

mov count_bitCh,a

shft_rgt_ostk: clr c

mov a,bufer7

rrc a

mov bufer7,a

mov a,bufer6

rrc a

mov bufer6,a

mov a,bufer5

rrc a

mov bufer5,a

mov a,bufer4

rrc a

mov bufer4,a

djnz count_bitCh, shft_rgt_ostk

результат деления записываем а регистры temp3 - temp0

mov temp3,bufer7

mov temp2,bufer6

mov temp1,bufer5

mov temp0,bufer4

завершение операции поиска остатка от деления по модулю 2 ret

обработка значения остатка и исправление ошибки

DETECT_ERROR: mov DPTR,#ostatok_01; установка начального адреса таблицы

I) обработка значений синдромов при единичной ошибке

mov temp_reg1,#63; число вариантов перебора

установка значения для анализа первого бита для сообщения

acall ini_first_error

mov R0,#er_byte0; копируем побайтно регистры

mov R1,#er_vector0; er_byte0 - er_byte7 в регистры

acall save_r0_to_r1; er_vector0 - er_vector7 соответственно

error1_detect: mov R0,#er_vector0; копируем побайтно регистры

mov R1,#byte0; byte0 - byte7 в регистры

acall save_r0_to_r1; er_vector0 - er_vector7

acall compare_rem; обращение на выполнение проверки

jnz next_proverka; продолжить если не определено

ajmp error_disable; ошибки обнаружены, исправление

next_proverka: mov R0,#er_vector0; сдвиг влево на 1 такт регистров

acall shift_left8; er_vector0 - er_vector7

djnz temp_reg1, error1_detect

конец обработки единичной ошибки

II) обработка значений синдромов при двойной ошибке acall ini_first_error;

установка 1-го подвектора ошибок

дублирование первого подвектора ошибок

mov R0,#er_byte0; копируем побайтно регистры

mov R1,#byte0; er_byte0 - er_byte7 в регистры

acall save_r0_to_r1; byte0 - byte7 соответственно формируем второй

подвектор ошибок

mov R0,#byte0; сдвинуть на один такт влево byte

acall shift_left8; регистры с меткой byte

дублируем второй подвектор ошибок

mov R1,#reg_err20; сохранить регистры byte0 - byte7

mov R0,#byte0; в регистрах reg_err20-reg_err27

acall save_r0_to_r1; соответственно



подготовка проверочного вектора сложением 1-го и 2-го подвекторов ошибок; полученное значение заносится в вектор ошибок для коррекции сообщения; вектор ошибок обозначен регистрами er_vector0 - er_vector7

proverka_2_63: mov a,er_byte0

orl byte0,a

mov er_vector0,byte0

mov a,er_byte1

orl byte1,a

mov er_vector1,byte1

mov a,er_byte2

orl byte2,a

mov er_vector2,byte2

mov a,er_byte3

orl byte3,a

mov er_vector3,byte3

mov a,er_byte4

orl byte4,a

mov er_vector4,byte4

mov a,er_byte5

orl byte5,a

mov er_vector5,byte5

mov a,er_byte6

orl byte6,a

mov er_vector6,byte6

mov a,er_byte7

orl byte7,a

mov er_vector7,byte7

acall compare_rem; обращение на выполнение проверки

jnz next_proverka_2; продолжить если не определено

ajmp error_disable; ошибки обнаружены, исправление

next_proverka_2: mov R0,#reg_err20; сдвиг байтов второго подвектора acall shift_left8;

mov R0,#reg_err20; сохранить регистры reg_err20-reg_err27

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

mov a,byte7; проверка положения второго

cjne a,#80h,proverka_2_63; подвектора

mov R0,#er_byte0; сдвиг в лево байтов

acall shift_left8; первого подвектора

mov a,er_byte7; проверка положения первого подвектора

xrl a,#40h

jz _detect_er3; и выход если конечное

mov R0,#er_byte0; сохранить регистры er_byte0-er_byte7

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

получение нового положения второго подвектора

mov R0,#byte0; сдвиг байтов второго подвектора

acall shift_left8

mov R1,#reg_err20; сохранить регистры byte0 - byte7

mov R0,#byte0; в регистрах reg_err20-reg_err27

acall save_r0_to_r1; соответственно

sjmp proverka_2_63; переход на новый цикл обработки

III) обработка значений синдромов при тройной ошибке _detect_er3: acall ini_first_error; установка 1-го подвектора ошибок; дублирование первого подвектора ошибок

mov R0,#er_byte0; копируем побайтно регистры

mov R1,#reg_err20; er_byte0 - er_byte7 в регистры

acall save_r0_to_r1; reg_err20 - reg_err27 соответственно

формируем второй подвектор ошибок mov R0,#reg_err20; сдвинуть на один такт влево reg_err20

acall shift_left8; регистры с меткой byte

формируем третий подвектор ошибок

mov R0,#reg_err20; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err30; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err30; сдвинуть на один такт влево reg_err20

acall shift_left8; регистры с меткой byte

дублируем третий подвектор ошибок

mov R0,#reg_err30; сохранить регистры reg_err30-reg_err37

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

подготовка проверочного вектора сложением 1-го,2-го и 3-го подвекторов ошибок; полученное значение заносится в вектор ошибок для коррекции сообщения; вектор ошибок обозначен регистрами er_vector0 - er_vector7

proverka_3_63: mov a,er_byte0

orl a,reg_err20

orl byte0,a

mov er_vector0,byte0

mov a,er_byte1

orl a,reg_err21

orl byte1,a

mov er_vector1,byte1

mov a,er_byte2

orl a,reg_err22

orl byte2,a

mov er_vector2,byte2

mov a,er_byte3

orl a,reg_err23

orl byte3,a

mov er_vector3,byte3

mov a,er_byte4

orl a,reg_err24

orl byte4,a

mov er_vector4,byte4

mov a,er_byte5

orl a,reg_err25

orl byte5,a

mov er_vector5,byte5

mov a,er_byte6

orl a,reg_err26

orl byte6,a

mov er_vector6,byte6

mov a,er_byte7

orl a,reg_err27

orl byte7,a

mov er_vector7,byte7

acall compare_rem; обращение на выполнение проверки

jnz next_proverka_3; продолжить если не определено

ajmp error_disable; ошибки обнаружены, исправление

next_proverka_3: mov R0,#reg_err30; сдвиг байтов третьего подвектора

acall shift_left8;

mov R0,#reg_err30; сохранить регистры reg_err20-reg_err27

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно



mov a,byte7; проверка положения второго

cjne a,#80h,proverka_3_63; подвектора

mov R0,#reg_err20; сдвиг в лево байтов

acall shift_left8; первого подвектора

mov a,reg_err27; проверка положения второго подвектора xrl a,#40h

jz modif_vect3; и выход если конечное

формируем третий подвектор ошибок

mov R0,#reg_err20; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err30; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err30; сдвинуть на один такт влево reg_err20

acall shift_left8; регистры с меткой byte

дублируем третий подвектор ошибок

mov R0,#reg_err30; сохранить регистры reg_err30-reg_err37

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

sjmp proverka_3_63

modif_vect3: mov R0,#er_byte0; сдвиг байтов 1-го подвектора

acall shift_left8;

mov a,er_byte7; проверка положения первого подвектора xrl a,#20h jz _detect_er4; и выход если конечное дублирование первого подвектора ошибок

mov R0,#er_byte0; копируем побайтно регистры

mov R1,#reg_err20; er_byte0 - er_byte7 в регистры

acall save_r0_to_r1; reg_err0 - reg_err7 соответственно

формируем второй подвектор ошибок

mov R0,#reg_err20; сдвинуть на один такт влево reg_err20

acall shift_left8; регистры с меткой byte

формируем третий подвектор ошибок

mov R0,#reg_err20; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err30; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err30; сдвинуть на один такт влево reg_err20

acall shift_left8; регистры с меткой byte

кодер циклический декодер ошибка

дублируем третий подвектор ошибок

mov R0,#reg_err30; сохранить регистры reg_err30-reg_err37

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

ajmp proverka_3_63

IV) обработка значений синдромов при четверной ошибке _detect_er4: acall ini_first_error; установка 1-го подвектора ошибок; дублирование первого подвектора ошибок

mov R0,#er_byte0; копируем побайтно регистры

mov R1,#reg_err20; er_byte0 - er_byte7 в регистры

acall save_r0_to_r1; reg_err20 - reg_err27 соответственно

формируем второй подвектор ошибок

mov R0,#reg_err20; сдвинуть на один такт влево reg_err20

acall shift_left8; регистры с меткой byte

формируем третий подвектор ошибок

mov R0,#reg_err20; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err30; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err30; сдвинуть на один такт влево reg_err20

acall shift_left8; регистры с меткой byte

формируем четвертый подвектор ошибок

mov R0,#reg_err30; сохранить регистры reg_err30 - reg_err37

mov R1,#reg_err40; в регистрах reg_err40-reg_err47

acall save_r0_to_r1; соответственно

mov R0,#reg_err40; сдвинуть на один такт влево reg_err40

acall shift_left8; регистры с меткой byte

дублируем четвертый подвектор ошибок

mov R0,#reg_err40; сохранить регистры reg_err40-reg_err47

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

подготовка проверочного вектора сложением 1-го,2-го,3-го и 4-го подвекторов ошибок, полученное значение заносится в вектор ошибок для коррекции сообщения; вектор ошибок обозначен регистрами er_vector0 - er_vector7

proverka_4_63: mov a,er_byte0

orl a,reg_err20

orl a,reg_err30

orl byte0,a

mov er_vector0,byte0

mov a,er_byte1

orl a,reg_err21

orl a,reg_err31

orl byte1,a

mov er_vector1,byte1

mov a,er_byte2

orl a,reg_err22

orl a,reg_err32

orl byte2,a

mov er_vector2,byte2

mov a,er_byte3

orl a,reg_err23

orl a,reg_err33

orl byte3,a

mov er_vector3,byte3

mov a,er_byte4

orl a,reg_err24

orl a,reg_err34

orl byte4,a

mov er_vector4,byte4

mov a,er_byte5

orl a,reg_err25

orl a,reg_err35

orl byte5,a

mov er_vector5,byte5

mov a,er_byte6

orl a,reg_err26

orl a,reg_err36

orl byte6,a

mov er_vector6,byte6

mov a,er_byte7

orl a,reg_err27

orl a,reg_err37

orl byte7,a

mov er_vector7,byte7

acall compare_rem; обращение на выполнение проверки

jnz next_proverka_4; продолжить если не определено

ajmp error_disable; ошибки обнаружены, исправление

next_proverka_4: mov R0,#reg_err40; сдвиг байтов четвертого подвектора

acall shift_left8;

mov R0,#reg_err40; сохранить регистры reg_err40-reg_err47

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

mov a,byte7; проверка положения второго

cjne a,#80h,proverka_4_63; подвектора

mov R0,#reg_err30; сдвиг влево байтов

acall shift_left8; первого подвектора

mov a,reg_err37; проверка положения второго подвектора

xrl a,#40h

jz modif_vect4; и выход если конечное

формируем третий подвектор ошибок

mov R0,#reg_err30; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err40; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err40; сдвинуть на один такт влево reg_err20

acall shift_left8; регистры с меткой byte

дублируем третий подвектор ошибок

mov R0,#reg_err40; сохранить регистры reg_err30-reg_err37

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

ajmp proverka_4_63

modif_vect4: mov R0,#reg_err20; сдвиг байтов 2-го подвектора acall shift_left8;

mov a,reg_err27; проверка положения первого подвектора

xrl a,#20h

jz modif_vect5; и выход если конечное

формируем третий подвектор ошибок

mov R0,#reg_err20; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err30; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err30; сдвинуть на один такт влево reg_err20

acall shift_left8; регистры с меткой byte

формируем четвертый подвектор ошибок

mov R0,#reg_err30; сохранить регистры reg_err30 - reg_err37

mov R1,#reg_err40; в регистрах reg_err40-reg_err47

acall save_r0_to_r1; соответственно

mov R0,#reg_err40; сдвинуть на один такт влево reg_err40

acall shift_left8; регистры с меткой byte

дублируем четвертый подвектор ошибок

mov R0,#reg_err40; сохранить регистры reg_err40-reg_err47

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

ajmp proverka_4_63

modif_vect5: mov R0,#er_byte0; сдвиг байтов 1-го подвектора acall shift_left8; mov a,er_byte7; проверка положения первого подвектора xrl a,#10h jz _detect_er5; и выход если конечное дублирование первого подвектора ошибок

mov R0,#er_byte0; копируем побайтно регистры

mov R1,#reg_err20; er_byte0 - er_byte7 в регистры

acall save_r0_to_r1; reg_err20 - reg_err27 соответственно

формируем второй подвектор ошибок

mov R0,#reg_err20; сдвинуть на один такт влево reg_err20

acall shift_left8; регистры с меткой byte

формируем третий подвектор ошибок

mov R0,#reg_err20; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err30; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err30; сдвинуть на один такт влево reg_err20

acall shift_left8; регистры с меткой byte

формируем четвертый подвектор ошибок

mov R0,#reg_err30; сохранить регистры reg_err30 - reg_err37

mov R1,#reg_err40; в регистрах reg_err40-reg_err47

acall save_r0_to_r1; соответственно

mov R0,#reg_err40; сдвинуть на один такт влево reg_err40

acall shift_left8; регистры с меткой byte

дублируем четвертый подвектор ошибок

mov R0,#reg_err40; сохранить регистры reg_err40-reg_err47

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

ajmp proverka_4_63

V) обработка значений синдромов при пятерной ошибке_detect_er5: acall ini_first_error; установка 1-го подвектора ошибок;

дублирование первого подвектора ошибок

mov R0,#er_byte0; копируем побайтно регистры

mov R1,#reg_err20; er_byte0 - er_byte7 в регистры

acall save_r0_to_r1; reg_err20 - reg_err27 соответственно

формируем второй подвектор ошибок

mov R0,#reg_err20; сдвинуть на один такт влево reg_err20

acall shift_left8; регистры с меткой byte

формируем третий подвектор ошибок

mov R0,#reg_err20; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err30; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err30; сдвинуть на один такт влево reg_err30

acall shift_left8; регистры с меткой byte

формируем четвертый подвектор ошибок

mov R0,#reg_err30; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err40; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err40; сдвинуть на один такт влево reg_err40

acall shift_left8; регистры с меткой byte

формируем пятый подвектор ошибок

mov R0,#reg_err40; сохранить регистры reg_err40 - reg_err47

mov R1,#reg_err50; в регистрах reg_err50-reg_err57

acall save_r0_to_r1; соответственно

mov R0,#reg_err50; сдвинуть на один такт влево reg_err50

acall shift_left8; регистры с меткой byte

дублируем пятый подвектор ошибок

mov R0,#reg_err50; сохранить регистры reg_err50-reg_err57

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

подготовка проверочного вектора сложением 1-го, 2-го, 3-го, 4-го и 5-го подвекторов ошибок, полученное значение заносится в вектор ошибок для коррекции сообщения. Вектор ошибок обозначен регистрами er_vector0 - er_vector7

proverka_5_63: mov a,er_byte0

orl a,reg_err20

orl a,reg_err30

orl a,reg_err40

orl byte0,a

mov er_vector0,byte0

mov a,er_byte1

orl a,reg_err21

orl a,reg_err31

orl a,reg_err41

orl byte1,a

mov er_vector1,byte1

mov a,er_byte2

orl a,reg_err22

orl a,reg_err32

orl a,reg_err42

orl byte2,a

mov er_vector2,byte2

mov a,er_byte3

orl a,reg_err23

orl a,reg_err33

orl a,reg_err43

orl byte3,a

mov er_vector3,byte3

mov a,er_byte4

orl a,reg_err24

orl a,reg_err34

orl a,reg_err44

orl byte4,a

mov er_vector4,byte4

mov a,er_byte5

orl a,reg_err25

orl a,reg_err35

orl a,reg_err45

orl byte5,a

mov er_vector5,byte5

mov a,er_byte6

orl a,reg_err26

orl a,reg_err36

orl a,reg_err46

orl byte6,a

mov er_vector6,byte6

mov a,er_byte7

orl a,reg_err27

orl a,reg_err37

orl a,reg_err47

orl byte7,a

mov er_vector7,byte7

acall compare_rem; обращение на выполнение проверки

jnz next_proverka_5; продолжить если не определено

ajmp error_disable; ошибки обнаружены, исправление

next_proverka_5: mov R0,#reg_err50; сдвиг байт пятого подвектораacall shift_left8;

mov R0,#reg_err50; сохранить регистры reg_err40-reg_err47

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

mov a,byte7; проверка положения второго

cjne a,#80h,proverka_5_63; подвектора

mov R0,#reg_err40; сдвиг в лево байтов

acall shift_left8; первого подвектора

mov a,reg_err47; проверка положения четвертого подвектора

xrl a,#40h

jz modif_vect6; и выход если конечное

формируем пятый подвектор ошибок

mov R0,#reg_err40; сохранить регисты reg_err40 - reg_err47

mov R1,#reg_err50; в регистрах reg_err50-reg_err57

acall save_r0_to_r1; соответственно

mov R0,#reg_err50; сдвинуть на один такт влево reg_err50

acall shift_left8; регистры с меткой byte

дублируем пятый подвектор ошибок

mov R0,#reg_err50; сохранить регистры reg_err50-reg_err57

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

ajmp proverka_5_63



modif_vect6: mov R0,#reg_err30; сдвиг влево байтов

acall shift_left8; первого подвектора

mov a,reg_err37; проверка положения третьего подвектора

xrl a,#20h

jz modif_vect7; и выход если конечное

формируем четвертый подвектор ошибок

mov R0,#reg_err30; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err40; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err40; сдвинуть на один такт влево reg_err40

acall shift_left8; регистры с меткой byte

формируем пятый подвектор ошибок

mov R0,#reg_err40; сохранить регистры reg_err40 - reg_err47

mov R1,#reg_err50; в регистрах reg_err50-reg_err57

acall save_r0_to_r1; соответственно

mov R0,#reg_err50; сдвинуть на один такт влево reg_err50

acall shift_left8; регистры с меткой byte

дублируем пятый подвектор ошибок

mov R0,#reg_err50; сохранить регистры reg_err50-reg_err57

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

ajmp proverka_5_63

modif_vect7: mov R0,#reg_err20; сдвиг в лево байтов

acall shift_left8; второго подвектора

mov a,reg_err27; проверка положения второго подвектора

xrl a,#10h

jz modif_vect8; и выход если конечное

формируем третий подвектор ошибок

mov R0,#reg_err20; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err30; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err30; сдвинуть на один такт влево reg_err30

acall shift_left8; регистры с меткой byte

формируем четвертый подвектор ошибок

mov R0,#reg_err30; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err40; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err40; сдвинуть на один такт влево reg_err40

acall shift_left8; регистры с меткой byte

формируем пятый подвектор ошибок

mov R0,#reg_err40; сохранить регистры reg_err40 - reg_err47

mov R1,#reg_err50; в регистрах reg_err50-reg_err57

acall save_r0_to_r1; соответственно

mov R0,#reg_err50; сдвинуть на один такт влево reg_err50

acall shift_left8; регистры с меткой byte

дублируем пятый подвектор ошибок

mov R0,#reg_err50; сохранить регистры reg_err50-reg_err57

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

ajmp proverka_5_63

modif_vect8: mov R0,#er_byte0; сдвиг байтов 1-го подвектора

acall shift_left8;

mov a,er_byte7; проверка положения первого подвектора

xrl a,#08h

jz error_not_detect; и выход если конечное

дублирование первого подвектора ошибок

mov R0,#er_byte0; копируем побайтно регистры

mov R1,#reg_err20; er_byte0 - er_byte7 в регистры

acall save_r0_to_r1; reg_err20 - reg_err27 соответственно

формируем второй подвектор ошибок

mov R0,#reg_err20; сдвинуть на один такт влево reg_err20

acall shift_left8; регистры с меткой byte



формируем третий подвектор ошибок

mov R0,#reg_err20; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err30; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err30; сдвинуть на один такт влево reg_err30

acall shift_left8; регистры с меткой byte

формируем четвертый подвектор ошибок

mov R0,#reg_err30; сохранить регистры reg_err20 - reg_err27

mov R1,#reg_err40; в регистрах reg_err30-reg_err37

acall save_r0_to_r1; соответственно

mov R0,#reg_err40; сдвинуть на один такт влево reg_err40

acall shift_left8; регистры с меткой byte

формируем пятый подвектор ошибок

mov R0,#reg_err40; сохранить регистры reg_err40 - reg_err47

mov R1,#reg_err50; в регистрах reg_err50-reg_err57

acall save_r0_to_r1; соответственно

mov R0,#reg_err50; сдвинуть на один такт влево reg_err50

acall shift_left8; регистры с меткой byte

дублируем пятый подвектор ошибок

mov R0,#reg_err50; сохранить регистры reg_err50-reg_err57

mov R1,#byte0; в регистрах byte0 - byte7

acall save_r0_to_r1; соответственно

ajmp proverka_5_63

Зациклить программу в этом месте и записать в порты р0 - р3 все нули если ошибка была обнаружена но не исправлена

error_not_detect: mov p0,#0

mov p1,#0

mov p2,#0

mov p3,#0

sjmp $

ini_first_error: mov er_byte0,#01h

mov er_byte1,#0

mov er_byte2,#0

mov er_byte3,#0

mov er_byte4,#0

mov er_byte5,#0

mov er_byte6,#0

mov er_byte7,#0

ret

compare_rem: acall clr_ctrl_byte

mov count_takt,#63

mov temp_reg2,#00;начальный адрес смешения в таблице

compare_loop:clr c; сдвиг вектора ошибки на один такт вправо

mov a,byte7

rrc a

mov byte7,a

mov a,byte6

rrc a

mov byte6,a

mov a,byte5

rrc a

mov byte5,a

mov a,byte4

rrc a

mov byte4,a

mov a,byte3

rrc a

mov byte3,a

mov a,byte2

rrc a

mov byte2,a

mov a,byte1

rrc a

mov byte1,a

mov a,byte0

rrc a

mov byte0,a

jnc table_vect; если младший бит 0, то не читать таблицу

чтение таблицы

mov a,temp_reg2

movc a,@a+DPTR

xrl cntrl_byte3,a

inc temp_reg2

mov a,temp_reg2

movc a,@a+DPTR

xrl cntrl_byte2,a

inc temp_reg2

mov a,temp_reg2

movc a,@a+DPTR

xrl cntrl_byte1,a

inc temp_reg2

mov a,temp_reg2

movc a,@a+DPTR

xrl cntrl_byte0,a

inc temp_reg2

sjmp table_ok

table_vect: mov a,temp_reg2; увеличить смещение таблицы на 4

add a,#4

mov temp_reg2,a

table_ok: djnz count_takt, compare_loop

сравниваем полученный остаток из таблиц с остатком от деления

mov a,temp3

xrl cntrl_byte3,a

mov a,temp2

xrl cntrl_byte2,a

mov a,temp1

xrl cntrl_byte1,a

mov a,temp0

xrl cntrl_byte0,a

проверка равны ли (т.е значение байтов сntrl_byte равно 0)

clr a

orl a,cntrl_byte3

orl a,cntrl_byte2

orl a,cntrl_byte1

orl a,cntrl_byte0

востановление байта ошибок

ret; возвращает " 0 " в аккумуляторе если вектор ошибок верен

таблицы остатков - синдромов от деления, номер таблицы - порядковый номер разряда, начиная с 1, на ошибку которого указывает синдром;

Таблицы представлены старшим байтом в левой части, для наглядности

ostatok_синдомы ошибок для битов 0 -26

ostatok_01: db 00h, 00h, 00h, 01h; коррекция бита 0

ostatok_02: db 00h, 00h, 00h, 02h; коррекция бита 1

ostatok_03: db 00h, 00h, 00h, 04h; коррекция бита 2

ostatok_04: db 00h, 00h, 00h, 08h; коррекция бита 3

ostatok_05: db 00h, 00h, 00h, 10h; коррекция бита 4

ostatok_06: db 00h, 00h, 00h, 20h; коррекция бита 5

ostatok_07: db 00h, 00h, 00h, 40h; коррекция бита 6

ostatok_08: db 00h, 00h, 00h, 80h; коррекция бита 7

ostatok_09: db 00h, 00h, 01h, 00h; коррекция бита 8

ostatok_10: db 00h, 00h, 02h, 00h; коррекция бита 9

ostatok_11: db 00h, 00h, 04h, 00h; коррекция бита 10

ostatok_12: db 00h, 00h, 08h, 00h; коррекция бита 11

ostatok_13: db 00h, 00h, 10h, 00h; коррекция бита 12

ostatok_14: db 00h, 00h, 20h, 00h; коррекция бита 13

ostatok_15: db 00h, 00h, 40h, 00h; коррекция бита 14

ostatok_16: db 00h, 00h, 80h, 00h; коррекция бита 15

ostatok_17: db 00h, 01h, 00h, 00h; коррекция бита 16

ostatok_18: db 00h, 02h, 00h, 00h; коррекция бита 17

ostatok_19: db 00h, 04h, 00h, 00h; коррекция бита 18

ostatok_20: db 00h, 08h, 00h, 00h; коррекция бита 19

ostatok_21: db 00h, 10h, 00h, 00h; коррекция бита 20

ostatok_22: db 00h, 20h, 00h, 00h; коррекция бита 21

ostatok_23: db 00h, 40h, 00h, 00h; коррекция бита 22

ostatok_24: db 00h, 80h, 00h, 00h; коррекция бита 23

ostatok_25: db 01h, 00h, 00h, 00h; коррекция бита 24

ostatok_26: db 02h, 00h, 00h, 00h; коррекция бита 25

ostatok_27: db 04h, 00h, 00h, 00h; коррекция бита 26

ostatok_синдомы ошибок для битов 27 -62

ostatok_28: db 00h, 6Eh, 81h, 13h; коррекция бита 27

ostatok_29: db 00h, 0DDh, 02h, 26h; коррекция бита 28

ostatok_30: db 01h, 0BAh, 04h, 4Ch; коррекция бита 29

ostatok_31: db 03h, 74h, 08h, 98h; коррекция бита 30

ostatok_32: db 06h, 0E8h, 11h, 30h; коррекция бита 31

ostatok_33: db 05h, 0BEh, 0A3h, 73h; коррекция бита 32

ostatok_34: db 03h, 13h, 0C7h, 0F5h; коррекция бита 33

ostatok_35: db 06h, 27h, 8Fh, 0EAh; коррекция бита 34

ostatok_36: db 04h, 21h, 9Eh, 0C7h; коррекция бита 35

ostatok_37: db 00h, 2Dh, 0BCh, 9Dh; коррекция бита 36

ostatok_38: db 00h, 5Bh, 79h, 3Ah; коррекция бита 37

ostatok_39: db 00h, 0B6h, 0F2h, 74h; коррекция бита 38

ostatok_40: db 01h, 6Dh, 0E4h, 0E8h; коррекция бита 39

ostatok_41: db 02h, 0DBh, 0C9h, 0D0h; коррекция бита 40

ostatok_42: db 05h, 0B7h, 93h, 0A0h; коррекция бита 41

ostatok_43: db 03h, 01h, 0A6h, 53h; коррекция бита 42

ostatok_44: db 06h, 03h, 4Ch, 0A6h; коррекция бита 43

ostatok_45: db 04h, 68h, 18h, 5Fh; коррекция бита 44

ostatok_46: db 00h, 0BEh, 0B1h, 0ADh; коррекция бита 45

ostatok_47: db 01h, 7Dh, 63h, 5Ah; коррекция бита 46

ostatok_48: db 02h, 0FAh, 0C6h, 0B4h; коррекция бита 47

ostatok_49: db 05h, 0F5h, 8Dh, 68h; коррекция бита 48

ostatok_50: db 03h, 85h, 9Bh, 0C3h; коррекция бита 49

ostatok_51: db 07h, 0Bh, 37h, 86h; коррекция бита 50

ostatok_52: db 06h, 78h, 0EEh, 1Fh; коррекция бита 51

ostatok_53: db 04h, 9Fh, 5Dh, 2Dh; коррекция бита 52

ostatok_54: db 01h, 50h, 3Bh, 49h; коррекция бита 53

ostatok_55: db 02h, 0A0h, 76h, 92h; коррекция бита 54

ostatok_56: db 05h, 40h, 0EDh, 24h; коррекция бита 55

ostatok_57: db 02h, 0EFh, 5Bh, 5Bh; коррекция бита 56

ostatok_58: db 05h, 0DEh, 0B6h, 0B6h; коррекция бита 57

ostatok_59: db 03h, 0D3h, 0ECh, 7Fh; коррекция бита 58

ostatok_60: db 07h, 0A7h, 0D8h, 0FEh; коррекция бита 59

ostatok_61: db 07h, 21h, 30h, 0EFh; коррекция бита 60

ostatok_62: db 06h, 2Ch, 0E0h, 0CDh; коррекция бита 61

ostatok_63: db 04h, 37h, 40h, 89h; коррекция бита 62

clr_ctrl_byte: mov cntrl_byte3, #0; подпрограмма очистки

mov cntrl_byte2,#0; контрольных байтов

mov cntrl_byte1,#0; сравнения остатка и полученного значения

mov cntrl_byte0,#0; при модификации таблицы

ret

подпрогрмма сдвига 8-ми байтов влево на 1 такт

shift_left8: clr c

mov a,@R0;1

rlc a

mov @R0,a

dec R0

mov a,@R0;2

rlc a

mov @R0,a

dec R0

mov a,@R0;3

rlc a

mov @R0,a

dec R0

mov a,@R0;4

rlc a

mov @R0,a

dec R0

mov a,@R0;5

rlc a

mov @R0,a

dec R0

mov a,@R0;6

rlc a

mov @R0,a

dec R0

mov a,@R0;7

rlc a

mov @R0,a

dec R0

mov a,@R0;8

rlc a

mov @R0,a

ret

подпрограмма копирования 8-ми байтов которые расположены подряд; начинается со старшего адреса расположение пар байтов

save_r0_to_r1: mov count_takt,#8

r0_to_r1: mov a,@R0

mov @R1,a

dec R0

dec R1

djnz count_takt, r0_to_r1

ret

исправленное значение сообщения находятся в регистрах er_byte7 - er_byte0

error_disable: mov a,bufer7

xrl er_vector7,a

mov a,bufer6

xrl er_vector6,a

mov a,bufer5

xrl er_vector5,a

mov a,bufer4

xrl er_vector4,a

mov a,bufer3

xrl er_vector3,a

mov a,bufer2

xrl er_vector2,a

mov a,bufer1

xrl er_vector1,a

mov a,bufer0

xrl er_vector0,a

mov p3,er_vector7; запись в порт Р3 по исправлению ошибок

mov p2,er_vector6; запись в порт Р2 по исправлению ошибок

mov p1,er_vector5; запись в порт Р1 по исправлению ошибок

mov p0,er_vector4; запись в порт Р0 по исправлению ошибок

sjmp $



Вывод

Как видно из таблицы расчета вариантов обработки ошибок, данный метод декодирования и исправления ошибок является ресурсоемким, поэтому для реализации данного метода необходимо использовать более мощные микроконтроллеры, например с архитектурой RISC и с как можно большей разрядностью, желательно 32 бита. Наиболее эффективно для микроконтроллеров с ядром MCS51 данным методом исправлять единичные и двойные ошибки, так как максимальное время на исправление пяти ошибок в старших разрядах исходного сообщения, занимает более 5-ти часов машинного времени при тактовой частоте микроконтроллера 12 МГц.

Поэтому данная программа для декодирования БЧХ-кода имеет скорее всего чисто теоретическое причинение для ознакомления с принципом кодирования и декодирования. Для практического применения рекомендуется выбирать либо другие алгоритмы кодирования - декодирования, например циклического сдвига, либо ставить акцент на более мощные микроконтроллеры или схемы ПЛИС.

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

...