2208

1. Write a program in the programming language you are familiar with :- A program to simulate the calculation of Fletcher checksum, use your full roll number as data for the sender (the output of sender is the input of receiver).

// Version : 01
#include<bits/stdc++.h>
using namespace std;
uint16_t Fletcher_16(string data, int n)
{
 uint16_t R = 0, L = 0, check_sum = 0;
 for (int i = 0; i < n; i++)
 {
 R = (R + data[i]) % 256;
 L = (L + R) % 256;
 }
 check_sum = L * 256 + R;
 return check_sum;
}
int main()
{
 string input = "BFH2001048F";
 cout << "Fletcher's checksum code for the input in hexadecimal is: ";
 printf("%X\n", Fletcher_16(input, input.size()));
}

// Version : 02
#include<bits/stdc++.h>
using namespace std;

#define uint uint16_t

uint Fletcher(string str){
	uint sum1=0, sum2=0;
	for(int i=0; i<(int)str.size(); i++)		{
		sum1 += (str[i]); sum1 %= 255;
		sum2 += sum1; sum2 %= 255;
	}
	
	return (sum2 << 8) | sum1;
}

int main()
{
		cout << "Write the roll : \n";
		string str;  getline(cin, str);
		printf("%x", Fletcher(str));
    return 0;
}

2. Write a program in the programming language you are familiar with :- A program to simulate the calculation of Adler checksum, use your full roll number as data for the sender(the output of sender is the input of receiver).

// Version : 01
#include<bits/stdc++.h> 
using namespace std; 
int main() 
{ 
    string msg,crc,encoded=""; 
    cout<<"enter your message : \n"; 
    getline(cin,msg); 
    cout<<"enter your crc generator : \n"; 
    getline(cin,crc); 
    int m=msg.length(),n=crc.length(); 
    encoded+=msg; 
    for(int i=1;i<=n-1;i++) 
    { 
        encoded+='0'; 
    } 
 
    for(int i=0;i<=encoded.length()-n; ) 
    { 
        for(int j=0;j<n;j++) 
        encoded[i+j]=(encoded[i+j]==crc[j])? '0' : '1'; 
        for( ;i<encoded.length()&&encoded[i]!='1';i++); 
 
 
    } 
    cout<< msg+encoded.substr(m) << "\n"; 
 
 
}

// Version  : 02
#include<bits/stdc++.h>
using namespace std;

#define uint uint32_t

uint Adler(string str){
	uint sum1=1, sum2=0;
	for(int i=0; i<(int)str.size(); i++){
		sum1 += (str[i]); sum1 %= 65521;
		sum2 += sum1; sum2 %= 65521;
	}
	return (sum2 << 16) | sum1;
}

int main()
{
		cout << "Write the roll : \n";
		
		string str; getline(cin, str);
		printf("%x", Adler(str));

    return 0;
}

3. Write a program in the programming language you are familiar with :-A program to simulate the calculation of cyclic redundancy check (CRC).

// Version : 01
#include <bits/stdc++.h>
using namespace std;
int main()
{
 int i, j, divlen, msglen;
 char input[100], div[100], temp[100];
 char quot[100], rem[100], div1[100];
 printf("Enter Data: ");
 gets(input);
 printf("Enter divisor: ");
 gets(div);
 divlen = strlen(div);
 msglen = strlen(input);
 strcpy(div1, div);
 for (i = 0; i < divlen - 1; i++)
 input[msglen + i] = '0';
 for (i = 0; i < divlen; i++)
 temp[i] = input[i];
 for (i = 0; i < msglen; i++)
 {
 quot[i] = temp[0];
 if (quot[i] == '0')
 {
 for (j = 0; j < divlen; j++)
 div[j] = '0';
 }
 else
 {
 for (j = 0; j < divlen; j++)
 div[j] = div1[j];
 }
 for (j = divlen - 1; j > 0; j--)
 {
 if (temp[j] == div[j])
 rem[j - 1] = '0';
 else
 rem[j - 1] = '1';
 }
 rem[divlen - 1] = input[i + divlen];
 strcpy(temp, rem);
 }
 strcpy(rem, temp);
 printf("\nQuotient is ");
 for (i = 0; i < msglen; i++)
 printf("%c", quot[i]);
 printf("\nRemainder is ");
 for (i = 0; i < divlen - 1; i++)
 printf("%c", rem[i]);
 printf("\nCodeword: ");
 for (i = 0; i < msglen; i++)
 printf("%c", input[i]);
 for (i = 0; i < divlen - 1; i++)
 printf("%c", rem[i]);
 printf("\n");
}

// Version : 03 
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
using namespace std;
int main()
{
    string data;
    string divisor;
    cout << "Enter Data : ";
    cin >> data;
    cout << "Enter Divisor : ";
    cin >> divisor;

    string temp_data = data;

    temp_data.append(divisor.length() - 1, '0');
    for (int i = 0; i < temp_data.length();)
    {
        bool flag = false;
        int temp;
        for (int j = 0; j < divisor.length(); j++)
        {
            if (temp_data[i] == divisor[j])
            {
                temp_data[i] = '0';
            }
            else
            {
                temp_data[i] = '1';
                if (!flag)
                {
                    temp = i;
                    flag = true;
                }
            }
            i++;
        }
        if (flag)
            i = temp;
        if (temp_data.length() - i < divisor.length())
            break;
    }
    string remainde;
    remainde.append(temp_data, data.length(), divisor.length() - 1);
    data.append(temp_data, data.length(), divisor.length() - 1);
    cout << "Remainder : " << remainde << endl;
    cout << "Code Word : " << data << endl;
}

4. A program to simulate the calculation of Hamming code generation for 5 bit data (e.g. the data is 01101)

#include<bits/stdc++.h>
using namespace std;
vector<char> generate_hamming(string message)
{
 int n = message.size(), p = 0, hammingLength, k = 0;
 int currentPower = 1;
 string str = message;
 while (currentPower < p + n + 1)
 {
 p++;
 currentPower *= 2;
 }
 hammingLength = n + p;
 reverse(str.begin(), str.end());
 vector<char> ans(hammingLength + 1, '0');
 for (int i = 1; i <= hammingLength; i++)
 {
 if (i & (i - 1)) //check if 'i' is a power of 2 or not, if 0 then power of 2 else not
 {
 ans[i] = str[k];
 k++;
 }
 }
 for (int i = 0; i <= p - 1; i++)
 {
 int XOR = 0, flag = 1, skipBit = (1 << i);
 for (int j = (1 << i); j <= hammingLength; j += skipBit)
 {
 if (!flag)
 {
 flag ^= 1;
 continue;
 }
 flag ^= 1;
 int l = j, limit = skipBit;
 while (limit > 0 && l <= hammingLength) //check limit and skipBit limit
 {
 XOR ^= (ans[l] - '0');
 l++, limit--;
 }
 }
 if (XOR) ans[(1 << i)] = '1';
 else ans[(1 << i)] = '0';
 }
 return ans;
}
int main()
{
 string message;
 vector<char> hammingCode;
 cout <<" data : ";
 cin >> message;
 hammingCode = generate_hamming(message);
 cout<< "Hamming Code is : ";
 for (int i = hammingCode.size() - 1; i >= 1; i--)
 cout <<hammingCode[i];
 cout << "\n";
}

5. Write a program in the programming language you are familiar with :- A program to simulate the calculation of error detection from the data (01101) with Hamming code

#include<bits/stdc++.h>
using namespace std;
int p = 0;
vector<char> generate_hamming(string message)
{
int n = message.size(), hammingLength, k = 0;
int currentPower = 1;
string str = message;
while (currentPower < p + n + 1) {
p++;
currentPower *= 2;
}
hammingLength = n + p;
reverse(str.begin(), str.end());
vector<char> ans(hammingLength + 1, '0');
for (int i = 1; i <= hammingLength; i++) {
if (i & (i - 1)) { //check if 'i' is a power of 2 or not, if 0 then power of 2 else not
ans[i] = str[k];
k++;
}
}
for (int i = 0; i <= p - 1; i++) {
int XOR = 0, flag = 1, skipBit = (1 << i);
for (int j = skipBit; j <= hammingLength; j += skipBit) {
if (!flag) {
flag ^= 1;
continue;
}
flag ^= 1;
int l = j, limit = skipBit;
while (limit > 0 && l <= hammingLength) { //check limit and skipBit limit
XOR ^= (ans[l] - '0');
l++, limit--;
}
}
if (XOR) ans[(1 << i)] = '1';
else ans[(1 << i)] = '0';
}
return ans;
}
bool check_error(vector<char> v)
{
int hammingLength = v.size() - 1;
for (int i = 0; i <= p - 1; i++) {
int XOR = 0, skipBit = (1 << i);
for (int j = (1 << i); j <= hammingLength; j += skipBit)
 {
int l = j, limit = skipBit;
while (limit > 0 && l <= hammingLength) { //check limit and skipBit limit
XOR ^= (v[l] - '0');
l++, limit--;
}
}
if (XOR == 1) return true;
}
return false;
}
int main()
{
string message;
bool error = 0;
vector<char> hammingCode;
cout << "Enter dataword: ";
cin >> message;
hammingCode = generate_hamming(message);
error = check_error(hammingCode);
if (error) cout << "Error found.\n";
else cout << "No error found.\n";
cout << "Generated hamming code: ";
for (int i = hammingCode.size() - 1; i >= 1; i--)
cout << hammingCode[i];
cout << "\n";
}

6. Using MATLAB generate the following signal NRZ

(Original one. If it doesn’t work, you must check another one below.)

clc;
clear all;

close all;
bits = [1 0 1 0 0 0 1 1 0];
bitrate = 1; % bits per second
figure;
[t,s] = unrz(bits,bitrate);
plot(t,s,'LineWidth',3);
axis([0 t(end) -0.1 1.1])
grid on;
title(['Unipolar NRZ: [' num2str(bits) ']']);
function [t,x] = unrz(bits, bitrate)
% UNRZ Encode bit string using unipolar NRZ code.
% [T, X] = UNRZ(BITS, BITRATE) encodes BITS array using unipolar NRZ
% code with given BITRATE. Outputs are time T and encoded signal
% values X.
T = length(bits)/bitrate; % full time of bit sequence
n = 200;
N = n*length(bits);
dt = T/N;
t = 0:dt:T;
x = zeros(1,length(t)); % output signal
for i = 0:length(bits)-1
 if bits(i+1) == 1
 x(i*n+1:(i+1)*n) = 1;
 else
 x(i*n+1:(i+1)*n) = 0;
 end
end
end

clc;
clear;
close all;

bits = [1 0 1 0 0 0 1 1 0];
bitrate = 1; % bits per second

figure;
[t,s] = unrz(bits,bitrate);
plot(t,s,'LineWidth',3);
axis([0 t(end) -0.1 1.1])
grid on;
title(['Unipolar NRZ: [' num2str(bits) ']']);

function [t,x] = unrz(bits, bitrate)
% UNRZ Encode bit string using unipolar NRZ code.
% [T, X] = UNRZ(BITS, BITRATE) encodes BITS array using unipolar NRZ
% code with given BITRATE. Outputs are time T and encoded signal
% values X.
T = length(bits)/bitrate; % full time of bit sequence
n = 200;
N = n*length(bits);
dt = T/N;
t = 0:dt:T;
x = zeros(1,length(t)); % output signal
for i = 0:length(bits)-1
    if bits(i+1) == 1
        x(i*n+1:(i+1)*n) = 1;
    else
        x(i*n+1:(i+1)*n) = 0;
    end
end
end

7. Using MATLAB generate the following signal RZ

(Original One. If it doesn’t work, check the next one.)

clc;
clear all;
close all;
bits = [1 0 1 0 0 0 1 1 0];
bitrate = 1; % bits per second
figure;
[t,s] = prz(bits,bitrate);
plot(t,s,'LineWidth',3);
axis([0 t(end) -1.1 1.1])
grid on;
title(['Polar RZ: [' num2str(bits) ']']);
function [t,x] = prz(bits, bitrate)
% PRZ Encode bit string using polar RZ code.
% [T, X] = PRZ(BITS, BITRATE) encodes BITS array using polar RZ
% code with given BITRATE. Outputs are time T and encoded signal
% values X.
T = length(bits)/bitrate; % full time of bit sequence
n = 200;
N = n*length(bits);
dt = T/N;
t = 0:dt:T;
x = zeros(1,length(t)); % output signal
for i = 0:length(bits)-1
 if bits(i+1) == 1
 x(i*n+1:(i+0.5)*n) = 1;
 x((i+0.5)*n+1:(i+1)*n) = 0;
 else
 x(i*n+1:(i+0.5)*n) = -1;
 x((i+0.5)*n+1:(i+1)*n) = 0;
 end
end
end

clc;
clear;
close all;

bits = [1 0 1 0 0 0 1 1 0];
bitrate = 1; % bits per second

figure;
[t,s] = prz(bits,bitrate);
plot(t,s,'LineWidth',3);
axis([0 t(end) -1.1 1.1])
grid on;
title(['Polar RZ: [' num2str(bits) ']']);

function [t,x] = prz(bits, bitrate)
% PRZ Encode bit string using polar RZ code.
% [T, X] = PRZ(BITS, BITRATE) encodes BITS array using polar RZ
% code with given BITRATE. Outputs are time T and encoded signal
% values X.
T = length(bits)/bitrate; % full time of bit sequence
n = 200;
N = n*length(bits);
dt = T/N;
t = 0:dt:T;
x = zeros(1,length(t)); % output signal
for i = 0:length(bits)-1
    if bits(i+1) == 1
        x(i*n+1:(i+0.5)*n) = 1;
        x((i+0.5)*n+1:(i+1)*n) = 0;
    else
        x(i*n+1:(i+0.5)*n) = -1;
        x((i+0.5)*n+1:(i+1)*n) = 0;
    end
end
end

8. Using MATLAB generate the following signal PCM.

clc;
close all;
clear all;
n=input('Enter n value for n-bit PCM system : ');
n1=input('Enter number of samples in a period i.e. sampling fequency: ');
L=2^n;
% Signal Generation where Amplitude Of signal is 10v
x=0:1/100:4*pi;
y=10*sin(x);
subplot(3,1,1);
plot(y);
title('Analog Signal');
ylabel('Amplitude');
xlabel('Time');
x=0:2*pi/n1:4*pi;% n1 number of samples have to be selected
s=10*sin(x);
subplot(3,1,2);
stem(s);grid on;
title('Sampled Sinal');
ylabel('Amplitude');
xlabel('Time');
% Quantization Process
vmax=10;
vmin=-vmax;
del=(vmax-vmin)/L;
part=vmin:del:vmax ; % level are between vmin and vmax with difference of del
code=vmin-(del/2):del:vmax+(del/2); % Contaion Quantized valuses
[ind,q]=quantiz(s,part,code); % Quantization process
% ind contain index number and q contain quantized values
l1=length(ind);
l2=length(q);
for i=1:l1
if(ind(i)~=0) % To make index as binary decimal so started from 0 to N
ind(i)=ind(i)-1;
end
i=i+1;
end
ind;
for i=1:l2
if(q(i)==vmin-(del/2)); % To make quantize value inbetween the levels
q(i)=vmin+(del/2);
end
end
q;
subplot(3,1,3);
stem(q);grid on; % Display the Quantize values
title('Quantized Signal');
ylabel('Amplitude');
xlabel('Time');
% Encoding Process
figure
code=de2bi(ind,'left-msb'); % Cnvert the decimal to binary
k=1;
for i=1:l1
for j=1:n
coded(k)=code(i,j); % convert code matrix to a coded row vector
j=j+1;
k=k+1;
end
i=i+1;
end
coded
subplot(2,1,1); grid on;
stairs(coded);% Display the encoded signal
axis([0 100 -2 3]);
title('Encoded Signal');
ylabel('Amplitude');
xlabel('Time');
% Demodulation Of PCM signal
qunt=reshape(coded,n,length(coded)/n);
index=bi2de(qunt','left-msb'); % Getback the index in decimal form
q=del*index+vmin+(del/2); % getback Quantized values
subplot(2,1,2); grid on;
plot(q);% Plot Demodulated signal
title('Demodulated Signal');
ylabel('Amplitude');
xlabel('Time');

Input : 4
16