Дев’ята сигнатура

0000000000000000000000000000000000000000000000000011001100110011

(register, signature, z, input, iteration number)

0000000000000001 | 1000 || 1 || 1 || 0

0000000000000011 | 3000 || 1 || 1 || 1

0000000000000110 | 6000 || 0 || 0 || 2

0000000000001100 | F000 || 0 || 0 || 3

0000000000011001 | 9100 || 1 || 1 || 4

0000000000110011 | 3300 || 1 || 1 || 5

0000000001100110 | 6600 || 0 || 0 || 6

0000000011001101 | HF00 || 1 || 0 || 7

0000000110011010 | A910 || 0 || 1 || 8

0000001100110100 | 4330 || 0 || 1 || 9

0000011001101001 | 9660 || 1 || 0 || 10

0000110011010011 | 3HF0 || 1 || 0 || 11

0001100110100111 | 7A91 || 1 || 1 || 12

0011001101001111 | U433 || 1 || 1 || 13

0110011010011110 | P966 || 0 || 0 || 14

1100110100111100 | F3HF || 0 || 0 || 15

1001101001111001 | 97A9 || 1 || 0 || 16

0011010011110011 | 3U43 || 1 || 0 || 17

0110100111100111 | 7P96 || 1 || 0 || 18

1101001111001111 | UF3H || 1 || 0 || 19

1010011110011111 | U97A || 1 || 0 || 20

0100111100111110 | P3U4 || 0 || 0 || 21

1001111001111100 | F7P9 || 0 || 0 || 22

0011110011111001 | 9UF3 || 1 || 0 || 23

0111100111110010 | 2U97 || 0 || 0 || 24

1111001111100101 | 5P3U || 1 || 0 || 25

1110011111001011 | CF7P || 1 || 0 || 26

1100111110010111 | 79UF || 1 || 0 || 27

1001111100101111 | U2U9 || 1 || 0 || 28

0011111001011111 | U5P3 || 1 || 0 || 29

0111110010111110 | PCF7 || 0 || 0 || 30

1111100101111101 | H79U || 1 || 0 || 31

//////////////////////////////////////////////////////////////////////////

1111100101111101| H79U

Листинг:

getcode.cpp

// getcode.cpp : Defines the entry point for the console application.

#include "stdafx.h"

#include <stdio.h>

#include <conio.h>

#include <math.h>

#include <stdlib.h>

#include <string>

#include <iostream>

#include <fstream>

#include <bitset>

using namespace std;

const int N = 64;

bitset<N> x1, x2, x3, x4, x5, x6;

bitset<N> o1, o2, o3, o4, o5, o6, o7, o8, o9;

ofstream fout;

void WriteInFile();

void GetOutputs();

void GenInputs();

void GenerateX(int _frenq, bitset<N> &input);

int _tmain(int argc, _TCHAR* argv[])

{

fout.open("out.txt");

GenInputs();

GetOutputs();

WriteInFile();

return 0;

}

void GenerateX(int freq, bitset<N> &input)

{

bool curbit=0;

for (register int i(0); i < N; ++i)

{

if (!(i % freq))

curbit =! curbit;

input[i] = curbit;

}

}

void GenInputs()

{

x1.reset();

x2.reset();

x3.reset();

x4.reset();

x5.reset();

x6.reset();

GenerateX(1, x1);

GenerateX(2, x2);

GenerateX(4, x3);

GenerateX(8, x4);

GenerateX(16, x5);

GenerateX(32, x6);

}

void GetOutputs()

{

for (register int i(0); i < N; ++i)

{

o1[i] = ! x2[i];

o6[i] = ! x5[i];

o2[i] = ! o1[i];

o7[i] = ! o6[i];

o3[i] = x1[i] & o6[i] & o1[i];

o5[i] = o6[i] & o1[i] & x3[i];

o8[i] = x4[i] & o2[i] & o7[i];

o9[i] = o2[i] & o7[i] & x6[i];

o4[i] = o3[i] | o5[i] | o8[i] | o9[i];

}

}

void WriteInFile()

{

fout<<"\t(input signals, output signals):\n";

for (register int i(0); i < N; ++i)

{

fout << x1[i] << " " << x2[i] << " " << x3[i] << " " << x4[i] <<" " << x5[i] << " " << x6[i] <<

"\t" << o1[i] << " " << o2[i] << " " << o3[i] << " " << o4[i] << " " << o5[i] << " " << o6[i] <<

" " << o7[i] << " " << o8[i] << " " << o9[i] << " " << endl;

}

fout << "//////////////////////////////////////////////////////////////////////////\n";

fout << "\tOutput signals(for copy into program text):\n";

fout << "g_str=\"" << o1.to_string() << "\";\n";

fout << "//g_str=\"" << o2.to_string() << "\";\n";

fout << "//g_str=\"" << o3.to_string() << "\";\n";

fout << "//g_str=\"" << o4.to_string() << "\";\n";

fout << "//g_str=\"" << o5.to_string() << "\";\n";

fout << "//g_str=\"" << o6.to_string() << "\";\n";

fout << "//g_str=\"" << o7.to_string() << "\";\n";

fout << "//g_str=\"" << o8.to_string() << "\";\n";

fout << "//g_str=\"" << o9.to_string() << "\";\n";

}

getcode.cpp

// KIDS_6.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include <stdio.h>

#include <conio.h>

#include <math.h>

#include <stdlib.h>

#include <string>

#include <fstream>

#include <iostream>

#include <bitset>

using namespace std;

const int N = 64;

const int R = 16; //register length

const int Ti = 32; //window

ofstream fout;

bitset<N> g_data;

bitset<N> g_curdata;

string g_str;

void SetData();

bitset<R> GetReg(bitset<N> m_input);

string GetIdicator(bitset<R> input);

int _tmain(int argc, _TCHAR* argv[])

{

fout.open("out_.txt",ios::app);

cout << "Bit number for testing is " << N << ";\n";

SetData();

bitset<R> code;

string indicator;

code = GetReg(g_data);

indicator = GetIdicator(code);

fout << "//////////////////////////////////////////////////////////////////////////\n" <<

code.to_string() << "| " << indicator << endl;

return 0;

}

void SetData()

{

while (1)

{

//g_str="1100110011001100110011001100110011001100110011001100110011001100";

//g_str="0011001100110011001100110011001100110011001100110011001100110011";

//g_str="0100010001000100000000000000000001000100010001000000000000000000";

//g_str="0100110001001100000000000011001101001100010011000011001100110011";

//g_str="0000110000001100000000000000000000001100000011000000000000000000";

//g_str="1111111111111111000000000000000011111111111111110000000000000000";

//g_str="0000000000000000111111111111111100000000000000001111111111111111";

//g_str="0000000000000000000000000011001100000000000000000000000000110011";

g_str="0000000000000000000000000000000000000000000000000011001100110011";

if (g_str.size() != N)

{

cout<<"Length of entered data is wrong. Please, enter again( "<<N<<")\n\t";

cout<<g_str.size()<<"\n\t";

}

else

{

break;

}

}

fout<<g_str<<endl;

for (register int i(0); i < N; i++)

{

if (g_str[i] == '1')

{

g_data[N-1-i] = 1;

}

else

{

g_data[N-1-i] = 0;

}

}

}

string GetIdicator(bitset<R> input)

{

string sig = "0000";

bitset<4> tmpBit;

for (register int i(0); i < 4; ++i)

{

tmpBit[0] = input[i*4+0];

tmpBit[1] = input[i*4+1];

tmpBit[2] = input[i*4+2];

tmpBit[3] = input[i*4+3];

int mySig = (int)tmpBit.to_ulong();

if (mySig > 15)

{

cout<<"GetIdicator: error\n";

exit(0);

}

switch(mySig)

{

case 0 : sig[i] = '0'; break;

case 1 : sig[i] = '1'; break;

case 2 : sig[i] = '2'; break;

case 3 : sig[i] = '3'; break;

case 4 : sig[i] = '4'; break;

case 5 : sig[i] = '5'; break;

case 6 : sig[i] = '6'; break;

case 7 : sig[i] = '7'; break;

case 8 : sig[i] = '8'; break;

case 9 : sig[i] = '9'; break;

case 10 : sig[i] = 'A'; break;

case 11 : sig[i] = 'C'; break;

case 12 : sig[i] = 'F'; break;

case 13 : sig[i] = 'H'; break;

case 14 : sig[i] = 'P'; break;

case 15 : sig[i] = 'U'; break;

}

}

return sig;

}

bitset<R> GetReg(bitset<N> m_input)

{

bitset<R> reg;

unsigned int cur_z(0);

reg.reset();

if (Ti > N)

{

cout<<"Error: you'd change window duration\n";

exit(0);

}

fout<<"(register, signature, z, input, iteration number)\n";

for (int j=0; j<Ti; j++)

{

cur_z = reg[15]^reg[11]^reg[8]^reg[6]^m_input[j];

reg <<= 1;

reg[0] = cur_z;

fout << reg.to_string()<<" | "<<GetIdicator(reg)<<" || "<<cur_z<<" || "<<m_input[j]<<" || "<<j<<"\n";

}

return reg;

}

Висновки:

В ході виконання роботи був побудований сигнатурний аналізатор, а також досліджені сигнатури для заданої схеми.