В курсовом проекте необходим лишь контроль циклическим кодом, то есть контроль ошибок. Для обнаружения ошибки достаточно разделить принятую последовательность на образующий полином и проанализировать остаток. При нулевом остатке ошибок при передаче не обнаружено, в противном случае в принятой последовательности содержатся ошибки и требуется повторная передача блока. Аналогично кодеру, n-бит старшим разрядом вперед поступают на вход схемы деления на образующий полином Р(х), при этом ключ К1 в положении «1». После передачи n-символов схема управления переключает ключ К1 в положение «2» и остаток за r тактов поступает на УУ. Структурная схема декодера будет иметь вид.



Рисунок 3.6 - Структурная схема декодера

Выводы к главе 3

В процессе проектирования были разработаны структурные схемы приемного и передающего устройства, а также кодирующего и декодирующего устройства согласно заданному полиному, описаны алгоритмы работы передающей и приемных частей СПД. На основании полученных данных можно приступить к программной реализации кодера и декодера.



4. Разработка кодирующего и декодирующего устройства

4.1 Описание программы

Общие сведения

В соответствии с заданием на курсовой проект был разработан программный продукт «Передача и прием информации с использованием CRC - кода», наглядно демонстрирующий работу кодера и декодера циклического кода. Приложение было разработано в среде программирования C++ Builder 5.0. Компиляция выполнена без использования динамических библиотек и runtime пакетов с целью обеспечения переносимости программы на компьютер, где не установлена среда C++ Builder 5.0. Для функционирования приложения на компьютере должна быть установлена операционная система семейства Microsoft Windows. Аппаратные требования приложения невелики, благодаря чему оно может быть использовано и на «слабых» компьютерах.

Функциональное значение

Приложение наглядно демонстрирует формирование информационной и проверочной последовательности кодером, внесение каналом передачи данных вектора ошибок, выявление декодером наличия ошибок в принятой последовательности.

Программа предназначена лишь для демонстрации работы кодера и декодера циклического кода, поэтому с помощью неё возможно преобразование информационной последовательности ограниченной длины. Степень образующего полинома также ограничена.

Входные данные

Программный продукт позволяет вводить данные с клавиатуры или загружать из файла. Исходными данными являются:

· информационная последовательность,

· образующий полином P(x),

· вектор ошибок

Ввод названных данных производится в двоичном виде (нули и единицы), что позволяет наглядно анализировать работу системы.

Выходные данные

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

Математическая постановка задачи

Циклические коды находят наибольшее распространение в системах передачи данных с решающей обратной связью, что обусловлено их высокими корректирующими свойствами, сравнительно простой реализацией, невысокой избыточностью. Особенно они эффективны при обнаружении пакетов ошибок. Циклические коды относятся к блочным систематическим кодам, в которых каждая комбинация кодируется самостоятельно в виде блока таким образом, что информационные k и проверочные г элементы всегда находятся на определенных местах. Для упрощения процедуры кодирования и декодирования проверочные биты размещают в конце блока. Кодирование передаваемого сообщения осуществляется умножением двоичной последовательности G(x) на одночлен хr, имеющий ту же степень, что и образующий полином Р(х), с добавлением к этому произведению остатка R(x), полученного после деления произведения G(x)*xr на образующий полином, т. е. передаваемое в канал связи сообщение F(x) имеет вид:



F(x) = G(x)* xr+R(x). (4.1)

При декодировании принимаемая последовательность F(x) снова делится на образующий полином Р(х). Полученный нулевой остаток R(x)=0 свидетельствует об отсутствии ошибок в принятом блоке, а отличие от нуля - о наличии ошибок.

Описание логической структуры

Для моделирования работы кодера и декодера циклического кода в составы программы был включен класс Coder. В состав класса входят следующие переменные:

Таблица 4.1 - Переменные класса Coder

Имя переменной	Тип	Комментарии
Step_P	integer	Степень образующего полинома
V		Объем передаваемой информации
i		Счетчики в циклах
j
Inf	bool *	Указатель на массив информации
Pol		Указатель на массив представления полинома
Reg_Cod		Указатель на массив представления кодера
Reg_Dec		Указатель на массив представления декодера
Err		Указатель на вектор ошибок

Для представления информации в программе используется тип bool. Это приводит к увеличению объема занимаемой памяти, но в данном случае оно несущественно, так как передается лишь 240 бит. Каждый элемент массива Reg_Cod и Reg_Dec соответствует одной ячейке регистра.

Прототипы функций класса Coder:

· void Init();

· bool* getInf();

· bool* getPol();

· bool* getReg();

· void setInf(bool* );

· void setPol(bool* );

· void setReg(bool* );

· void setSt(int);

· int getSt();

· int getV();

· bool* getDec();

· bool* getErr();

· void setDec(bool* );

· void setErr(bool* );

· void coder::Cod();

· void coder::Decod().

Функция Init() - конструктор класса.

Большинство функций класса предназначены для «извлечения» или изменения значения закрытых переменных класса. Наибольший практический интерес представляют функции кодирования (void Cod() ) и декодирования (void Decod() ) информации.



Рисунок 4.1 - Блок-схема алгоритма функции Cod()



Рисунок 4.2 - Блок-схема алгоритма функции Decod()

Моделирование работы системы происходит в несколько этапов:

1. инициализация образующего полинома;

2. формирование информационной последовательности;

3. кодирование;

4. наложение вектора ошибок;

5. декодирование.

Все перечисленные этапы отражены в интерфейсе программы.

Рисунок 4.3 - Интерфейс программы.

4.2 Тестирование программной реализации

Пусть объем исходной информации равен 1 байту: I=10111011

Полином четвертой степени:

Для кодирования требуется умножить исходную информацию на xr и разделить на образующий полином. Полученный остаток от деления сложить по модулю два с исходной последовательностью, умноженной на xr. Для анализа работы кодера и декодера нужно знать не частное, а лишь остаток от деления.

Тест первый - нулевой вектор ошибок



1	0	1	1	1	0	1	1	0	0	0	0	1	1	0	0	1
1	1	0	0	1
	1	1	1	0	0
	1	1	0	0	1
			1	0	1	1	1
			1	1	0	0	1
				1	1	1	0	0
				1	1	0	0	1
						1	0	1	0	0
						1	1	0	0	1
							1	1	0	0	0
							1	1	0	1	1
								0	0	1	1

Рисунок 4.4 - Кодирование исходной последовательности

Остаток от деления в двоичном виде: 0011.

1	0	1	1	1	0	1	1	0	0	0	0
0	0	0	0	0	0	0	0	0	0	1	1
1	0	1	1	1	0	1	1	0	0	1	1

Для декодирования разделим информацию на образующий полином

1	0	1	1	1	0	1	1	0	0	1	1	1	1	0	0	1
1	1	0	0	1
	1	1	1	0	0
	1	1	0	0	1
			1	0	1	1	1
			1	1	0	0	1
				1	1	1	0	0
				1	1	0	0	1
						1	0	1	0	1
						1	1	0	0	0
							1	1	0	1	1
							1	1	0	1	1
								0	0	0	0

Рисунок 4.5 Декодирование информационной последовательности (нулевой вектор ошибок)

Нулевой вес остатка свидетельствует об отсутствии ошибок в принятой последовательности.

Тест второй (одиночная ошибка).

Исказим третий бит закодированной последовательности:

1	0	0	1	1	0	1	1	0	0	1	1	1	1	0	0	1
1	1	0	0	1
	1	0	1	0	0
	1	1	0	0	1
		1	1	0	1	1
		1	1	0	0	1
					1	0	1	0	0
					1	1	0	0	1
						1	1	0	1	1
						1	1	0	0	1
								0	1	0	1

Рисунок 4.6 - Декодирование информационной последовательности (одна ошибка)

Так как вес остатка не равен нулю, то информация передана с ошибками.

Тест третий (двойная ошибка).

Исказим 4-й и 5-й бит передаваемой последовательности

1	0	1	0	0	0	1	1	0	0	1	1	1	1	0	0	1
1	1	0	0	1
	1	1	0	1	0
	1	1	0	0	1
				1	1	1	1	0
				1	1	0	0	1
						1	1	1	0	1
						1	1	0	0	1
								1	0	0	1

Рисунок 4.7 - Декодирование информационной последовательности (две ошибки)

Остаток от деления свидетельствует о наличии ошибок в принятой последовательности.

Введем предложенные данные для тестирования программной реализации

Рисунок 4.8 - Тестирование программной реализации (первый тест)

Рисунок 4.9 - Тестирование программной реализации (второй тест)

Рисунок 4.10 - Тестирование программной реализации (третий тест)

Результаты тестирования полностью совпали с теорией, что свидетельствует о верной работе программной реализации.

Выводы к главе 4

В процессе проектирования была разработана программная реализация кодера и декодера циклического кода, описан интерфейс программы, а также приведены блок - схемы функций кодирования и декодирования информации.

Листинг программы приведен в приложении C.



Заключение

В результате проектирования получена система передачи данных, а именно приемная и передающая части устройства защиты от ошибок, реализующие прием и передачу сообщения при синхронном маркерном способе фазирования. Разработаны форматы сообщений, а также устройства кодирования и декодирования информации при передаче информационных сообщений и квитанций по прямому и обратному каналу. Используется полудуплексный канал связи и решающая обратная связь.



Приложение А

Список используемых сокращений

СПД - система передачи данных.

УФЦ - устройство фазирования по циклу.

ТИ - система телеизмерения.

ТС - система телесигнализации.

ТУ - система телеуправления.

ТУ-ТС - система телеуправления и телесигнализации.

ТИ-ТС - система телеизмерения и телесигнализации.

ОС - обратная связь.

ИОС - информационная обратная связь.

РОС - решающая обратная связь.

КОС - комбинированная обратная связь.

ГВП - групповое время прохождения.

УУ - устройство управления.

СПЗ счетчик повторных запросов.

БФИ - блок формирования информации.

КУ - кодирующее устройство.

БНУ - блок начальной установки.

ФТИ - формирователь тактовых импульсов.

ДНБ - датчик номера блока.

ДМК - датчик маркерной комбинации.

АОКС - анализатор обратного канала связи.

БАСИ - блок аварийной сигнализации и индикации.

Кл - ключевая схема.

ФСО - формирователь сигналов обмена.

ФК - фазовый корректор.

БН - буферный накопитель.

ДА - датчик адреса источника.

БППИ - блок преобразования передаваемой информации.

РгМК - регистр маркерной комбинации.

РгСК - регистр служебной комбинации.

ВхРг - входной регистр.

ДшМК - дешифратор маркерной комбинации.

ДКУ - декодирующее устройство.

ФСОС - формирователь сообщения обратной связи.

БАСК - блок анализа служебной комбинации.

БПВИ - блок преобразования и выдачи информации.



Приложение Б

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

Coder.h

#ifndef coderH

#define coderH

//-----------------

class coder

{protected:

private:

int Step_P; //степень полинома

bool *Inf; //указатель на массив информационных элеметов

bool *Pol; //указатель на массив представления полинома

bool *Reg_Cod;

bool *Err;

bool *Reg_Dec; //регистры кодера

int V; //объем информации

public:

int i,j; //счетчики

void Init();

bool* getInf();

bool* getPol();

bool* getReg();

void setInf(bool* );

void setPol(bool* );

void setReg(bool* );

void setSt(int);

int getSt();

int getV();

bool* getDec();

bool* getErr();

void setDec(bool* );

void setErr(bool* );

void coder::Cod();

void coder::Decod();};

Coder.cpp

extern PACKAGE coder *My;

//---------------------------------------------------------------------------

#endif

#include <vcl.h>

#pragma hdrstop

#include "coder.h"

pragma package(smart_init)

void coder::Init()

{ Inf=0; Pol=0; Reg_Cod=0; Step_P=0; Reg_Dec=0; Err=0; V=12; }

bool* coder::getInf() { return Inf; }

bool* coder::getPol() { return Pol; }

bool* coder::getReg() { return Reg_Cod; }

void coder::setInf(bool* A) { Inf=A; }

void coder::setPol(bool* A) { Pol=A;}

void coder::setReg(bool* A) { Reg_Cod=A; }

void coder::setSt(int B) { Step_P=B; }

int coder::getSt() { return Step_P; }

int coder::getV() { return V; }

bool* coder::getDec() { return Reg_Dec; }

bool* coder::getErr() { return Err;}

void coder::setDec(bool* A) { Reg_Dec=A;}

void coder::setErr(bool* A) { Err=A; }

void coder::Cod()

{if(Inf!=0&&Pol!=0)

{ if (Reg_Cod==0) Reg_Cod=new bool[Step_P];

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

{ Reg_Cod[i]=0; } //Начальное заполнение регистра

for(i=0;i<V-Step_P;i++)

{ bool Scan=Inf[i]^Reg_Cod[0];

if(Scan==0)

{for(j=0;j<Step_P;j++) { Reg_Cod[j]=Reg_Cod[j+1]; }

Reg_Cod[Step_P-1]=0; }

if(Scan==1)

{ for(j=0;j<Step_P;j++) { Reg_Cod[j]=Reg_Cod[j+1]^Pol[j+1]; }

Reg_Cod[Step_P-1]=1; } }

for(i=0;i<Step_P;i++) { Inf[V-Step_P+i]=Reg_Cod[i]; } } }

//-------------------------------------------------------------------------------

void coder::Decod()

{ if(Inf!=0&&Pol!=0&&Err!=0)

{ Reg_Dec=new bool[Step_P];

for(i=0;i<Step_P;i++) { Reg_Dec[i]=0; }

for(i=0;i<V;i++) { bool Scan=Reg_Dec[0];

if(Scan==0)

{for(j=0;j<Step_P-1;j++) { Reg_Dec[j]=Reg_Dec[j+1]; }

Reg_Dec[Step_P-1]=Inf[i]^Err[i]; }

if(Scan==1)

{ for(j=0;j<Step_P-1;j++) { Reg_Dec[j]=Reg_Dec[j+1]^Pol[j+1]; }

Reg_Dec[Step_P-1]=(Inf[i]^Err[i])^1; } } } }

Unit2.cpp

#pragma hdrstop

#include <stdio.h>

#include "Unit3.h"

#include "Unit2.h"

#include "coder.h"

#include <math.h>

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1; coder * My;

//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{ My=new coder; My->Init(); }

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{Randomize(); My->setSt(StrToInt(Edit1->Text));

int Step_P=My->getSt(); //считывание степени полинома

StringGrid2->ColCount=Step_P+1;

if(My->getPol()!=0) delete [Step_P+1] My->getPol(); //если массив не инициализирован

bool* Pol=new bool[Step_P+1]; Pol[0]=1; Pol[Step_P]=1;

for (i=1;i<Step_P;i++) { Pol[i]=random(2); } //инициализация полинома

for(i=0;i<Step_P+1;i++)

{ StringGrid2->Cells[i][1]=IntToStr(Pol[i]);

StringGrid2->Cells[i][0]=IntToStr(Step_P-i); } //вывод на экран

StringGrid2->Visible=true; Label2->Visible=true; My->setPol(Pol); }

//---------------------------------------------------------------------------

void __fastcall TForm1::Inversia_pol(TObject *Sender) //инверсия элемента в массиве полинома

{My->getPol()[Scan]=StrToInt(StringGrid2->Cells[Scan][1])^1;

StringGrid2->Cells[Scan][1]=IntToStr(My->getPol()[Scan]);}

//---------------------------------------------------------------------------

void __fastcall TForm1::scan(TObject *Sender, int ACol, int ARow,bool &CanSelect)

{Scan=ACol;}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)

{ int Step_P=My->getSt();

if(RadioButton1->Checked==true&&My->getSt()<32&&My->getSt()>2) //Заполнение информационного массива random

{ bool* Inf=My->getInf();

if(Inf==0) Inf=new bool[240];

StringGrid1->ColCount=240;

for(i=0;i<My->getV()-Step_P;i++) //Инициализация информации

{ Inf[i]=random(2); StringGrid1->Cells[i][0]=IntToStr(Inf[i]); }

for(i=My->getV()-Step_P;i<My->getV();i++)

{ Inf[i]=0; StringGrid1->Cells[i][0]=IntToStr(Inf[i]); } //Умоножаем на степень полинома

StringGrid1->Visible=true; My->setInf(Inf); }

if(RadioButton2->Checked==true&&My->getSt()<32&&My->getSt()>2) //загрузка из файла

{bool* Inf=My->getInf(); OpenDialog1->DefaultExt="isk"; OpenDialog1->FilterIndex=2;

if(OpenDialog1->Execute())

{ FILE *P=fopen(OpenDialog1->FileName.c_str(),"r"); fseek(P,0l,0);

char a[33]={0}; i=0;

do { a[i]=fgetc(P); i++; } while(feof(P)==0&&i<33);

if(Inf==0) Inf=new bool[My->getV()]; char A=128;

for(i=0;i<30;i++) //вывод на экран

{A=128;

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

{ Inf[8*i+j]=((a[i]&A)>>(7-j))&0x1; A=A/2; } }

StringGrid1->ColCount=My->getV(); StringGrid4->ColCount=My->getV();

for(i=0;i<My->getV();i++)

{StringGrid4->Cells[i][0]=IntToStr(Inf[i]); StringGrid1->Cells[i][0]=IntToStr(Inf[i]); }

StringGrid1->Visible=true; StringGrid4->Visible=true;

My->setInf(Inf); fclose(P); } } }

//---------------------------------------------------------------------------

void __fastcall TForm1::Inversia_inf(TObject *Sender)

{My->getInf()[Scan]=StrToInt(StringGrid1->Cells[Scan][0])^1;

StringGrid1->Cells[Scan][0]=IntToStr(My->getInf()[Scan]);}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender) //кодирование информации

{ My->Cod(); StringGrid3->ColCount=My->getSt(); StringGrid3->Visible=true;

for(i=0;i<My->getSt();i++) //Вывод на экран регистров кодера

{StringGrid3->Cells[i][0]=IntToStr(My->getReg()[i]); }

bool *Err=My->getErr();

if(Err==0) { Err=new bool[My->getV()]; }

StringGrid4->ColCount=My->getV();

for(i=0;i<My->getV();i++)

{ Err[i]=0; StringGrid4->Cells[i][0]=IntToStr(My->getInf()[i]);

StringGrid4->Cells[i][1]=IntToStr(0); }

StringGrid4->Visible=true; My->setErr(Err); }

//---------------------------------------------------------------------------

void __fastcall TForm1::Inversia_err(TObject *Sender)

{My->getErr()[Scan]=StrToInt(StringGrid4->Cells[Scan][1])^1;

StringGrid4->Cells[Scan][1]=IntToStr(My->getErr()[Scan]); }

//---------------------------------------------------------------------------

void __fastcall TForm1::Button4Click(TObject *Sender) //декодирование

{ My->Decod(); StringGrid5->ColCount=My->getSt(); StringGrid5->Visible=true;

for(i=0;i<My->getSt();i++) { StringGrid5->Cells[i][0]=IntToStr(My->getDec()[i]); }

int E=0 ; //наличие ошибки

for (i=0;i<My->getSt();i++) //проверка регстра декодара на наличие "1"

{ if(My->getDec()[i]==1) E=1; }

if (E==0) Label6->Caption="Ошибок не обнаружено" ; //нулевой вес остатка

if (E==1) Label6->Caption="Передача произведена с ошибками" ; }

//---------------------------------------------------------------------------

void __fastcall TForm1::BitBtn2Click(TObject *Sender) //Сохранение полинома в файл

{ SaveDialog1->DefaultExt="pol"; SaveDialog1->FilterIndex=2;

if(SaveDialog1->Execute())

{FILE *P=fopen(SaveDialog1->FileName.c_str(),"w+"); fseek(P,0l,0);

if(My->getPol()!=0)

{char A=0; int B=128;

for(i=0;i<=(My->getSt())/8;i++)

{ A=0; B=0x80;

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

{ if(8*i+j<=My->getSt()) A=A|((My->getPol()[i*8+j])*B);

B=B/2; }

fputc(A,P); }

fclose(P); } } }

//---------------------------------------------------------------------------

void __fastcall TForm1::BitBtn1Click(TObject *Sender) //Загрузка полинома из файла

{ OpenDialog1->DefaultExt="pol"; OpenDialog1->FilterIndex=2;

if(OpenDialog1->Execute())

{ FILE *P=fopen(OpenDialog1->FileName.c_str(),"r"); fseek(P,0l,0);

My->setSt(StrToInt(Edit1->Text)); char a[4]={0}; i=0;

do { a[i]=fgetc(P); i++; } while(feof(P)==0&&i<4);

if(My->getPol()!=0) delete [My->getSt()+1] My->getPol();

StringGrid2->ColCount=My->getSt()+1; bool* Pol=new bool[32]; char A=128;

for(i=0;i<4;i++) //вывод на экран

{ A=128;

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

{Pol[8*i+j]=((a[i]&A)>>(7-j))&0x1; A=A/2; } }

for(i=0;i<=My->getSt();i++)

{StringGrid2->Cells[i][0]=IntToStr(My->getSt()-i); StringGrid2->Cells[i][1]=IntToStr(Pol[i]); }

Edit1->Text=StrToInt(My->getSt()); StringGrid2->Visible=true; Label2->Visible=true;

My->setPol(Pol); fclose(P); } }

//---------------------------------------------------------------------------

void __fastcall TForm1::BitBtn3Click(TObject *Sender) //запись информации в файл

{SaveDialog1->InitialDir=GetCurrentDir(); SaveDialog1->DefaultExt="inf";

SaveDialog1->FilterIndex=2;

if(SaveDialog1->Execute())

{ FILE *P=fopen(SaveDialog1->FileName.c_str(),"w+");fseek(P,0l,0);

if(My->getInf()!=0)

{char A=0; int B=128;

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

{ A=0; B=0x80;

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

{ A=A|((My->getInf()[i*8+j])*B); B=B/2; }

fputc(A,P); } }

fclose(P); } }

//---------------------------------------------------------------------------

void __fastcall TForm1::BitBtn4Click(TObject *Sender) //сохранение значений регистров кодера

{ SaveDialog1->DefaultExt="cod"; SaveDialog1->FilterIndex=2;

if(SaveDialog1->Execute())

{FILE *P=fopen(SaveDialog1->FileName.c_str(),"w+"); fseek(P,0l,0);

if(My->getReg()!=0)

{ char A=0; int B=128;

for(i=0;i<=(My->getSt())/8;i++)

{ A=0; B=0x80;

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

{ if(8*i+j<My->getSt()) A=A|((My->getReg()[i*8+j])*B);

B=B/2; }

fputc(A,P); }

fclose(P); } } }

//---------------------------------------------------------------------------

void __fastcall TForm1::BitBtn6Click(TObject *Sender) //сохранение значений регистров декодера

{SaveDialog1->DefaultExt="dec"; SaveDialog1->FilterIndex=2;

if(SaveDialog1->Execute())

{ FILE *P=fopen(SaveDialog1->FileName.c_str(),"w+"); fseek(P,0l,0);

if(My->getDec()!=0)

{ char A=0; int B=128;

for(i=0;i<=(My->getSt())/8;i++)

{ A=0; B=0x80;

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

{ if(8*i+j<My->getSt()) A=A|((My->getDec()[i*8+j])*B); B=B/2; }

fputc(A,P); }

fclose(P); } } }

//---------------------------------------------------------------------------

void __fastcall TForm1::BitBtn5Click(TObject *Sender) //Сохранение вектора ошибок

{ SaveDialog1->DefaultExt="err"; SaveDialog1->FilterIndex=2;

if(SaveDialog1->Execute())

{ FILE *P=fopen(SaveDialog1->FileName.c_str(),"w+"); fseek(P,0l,0);

if(My->getErr()!=0)

{char A=0; int B=128;

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

{ A=0; B=0x80;

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

{ A=A|((My->getErr()[i*8+j])*B); B=B/2; }

fputc(A,P); } }

fclose(P); } }

//---------------------------------------------------------------------------

void __fastcall TForm1::BitBtn7Click(TObject *Sender) //Считывание вектора ошибок

{ bool* Err=My->getErr(); OpenDialog1->DefaultExt="err"; OpenDialog1->FilterIndex=2;

if(OpenDialog1->Execute())

{FILE *P=fopen(OpenDialog1->FileName.c_str(),"r"); fseek(P,0l,0); char a[33]={0}; i=0;

do { a[i]=fgetc(P); i++;} while(feof(P)==0&&i<33);

if(Err==0) Err=new bool[My->getV()];

char A=128;

for(i=0;i<30;i++) {A=128; //вывод на экран

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

{ Err[8*i+j]=((a[i]&A)>>(7-j))&0x1; A=A/2; } }

StringGrid4->ColCount=240;

for(i=0;i<My->getV();i++)

{StringGrid4->Cells[i][1]=IntToStr(Err[i]); }

StringGrid4->Visible=true; My->setErr(Err); fclose(P); } } }

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