Help needed forming a binary sequence

[anthony1947]

Hello,

The overall concept on this piece of code is to transmit a message that comprises words (decimal numbers with a range -127 to 128). To do this, I need to

1. Encode each word in its binary/two's complement (8-bit + Even parity bit) format
2. Concatenate the binary equivalent of the words to be transmitted to form a binary sequence
3. Send the binary sequence through a binary transmission channel
4. On the receiver, I need to do some error checking by assessing the parity bit
5. Decode the binary sequence to yield the message

I am currently facing a problem with the No. 2 (concatenate the binary equivalent of the words) and I would be grateful for any advice you can provide on its syntax.

Here is my code so far - (I built up the code for No. 1 & 5 myself. Although it works, you may find that it is inefficient in terms of the number of lines for its implementation; hence, I will be grateful for any advice to improve its implementation)

#include <iostream>
#include <fstream>
#include <cmath>

using namespace std;

// Define the class for binary sequence
class bin_seq;

// Define the class for word 
class word
{
	private:
		int bit1, bit2, bit3, bit4, bit5, bit6, bit7, bit8, parity;

	public:
		word();
		word(int u);
		~word();
		void Print();
		bool check_parity_OK();
		int DAC();
		friend class bin_seq;
};

// Constructor for word that initialises its data
word::word()
{
	bit1 = 0;
	bit2 = 0;
	bit3 = 0;
	bit4 = 0;
	bit5 = 0;
	bit6 = 0;
	bit7 = 0;
	bit8 = 0;
	parity = 0;
}

// Constructor for word that sets the values for the bits
word::word(int u)
{
	// Clip voltage if it is outside the range
	if (u > 127)
	{
		u = 127;
	}
	if (u < -128)
	{
		u = -128;
	}

	// Implement two's complement encoding
	// First, implement the binary equivalent
	int data = abs(u);
	int i = 0;
	int bit[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
	while (data != 0)
	{
		bit[i] = data%2;
		data = data/2;
		i = i + 1;
	}

	if (u >= 0)
	{
		// Assign positive words their binary representation 
		bit1	=	bit[0];
		bit2	=	bit[1];
		bit3	=	bit[2];
		bit4	=	bit[3];
		bit5	=	bit[4];
		bit6	=	bit[5];
		bit7	=	bit[6];
		bit8	=	bit[7];
	}

	if (u < 0)
	{
		// Assign negative words their two's complement
		// First, invert the bits
		// Invert bit 1
		if (bit[0]==0)
			bit1 = 1;
		else
			bit1 = 0;

		//Invert bit2
		if (bit[1]==0)
			bit2 = 1;
		else
			bit2 = 0;

		//Invert bit3
		if (bit[2]==0)
			bit3 = 1;
		else
			bit3 = 0;
		
		//Invert bit4
		if (bit[3]==0)
			bit4 = 1;
		else
			bit4 = 0;
		
		//Invert bit5
		if (bit[4]==0)
			bit5 = 1;
		else
			bit5 = 0;
		
		//Invert bit6
		if (bit[5]==0)
			bit6 = 1;
		else
			bit6 = 0;
		
		//Invert bit7
		if (bit[6]==0)
			bit7 = 1;
		else
			bit7 = 0;

		//Invert bit8
		if (bit[7]==0)
			bit8 = 1;
		else
			bit8 = 0;
		
		//Second, add one to the inverter binary word
		//Add one to bit1
		if ((bit1+1)==2)
			bit1 = 0;
		else
			bit1 = 1;

		//Add one to bit2, if required
		if (bit1==0)
			bit2 = bit2+1;
		else
			bit2 = bit2;
		if (bit2==2)
			bit2 = 0;

		//Add one to bit3, if required
		if ((bit1==0)&&(bit2==0))
			bit3 = bit3+1;
		else
			bit3 = bit3;
		if (bit3==2)
			bit3 = 0;

		//Add one to bit4, if required
		if ((bit1==0)&&(bit2==0)&&(bit3==0))
			bit4 = bit4+1;
		else
			bit4 = bit4;
		if (bit4==2)
			bit4 = 0;

		//Add one to bit5, if required
		if ((bit1==0)&&(bit2==0)&&(bit3==0)&&(bit4==0))
			bit5 = bit5+1;
		else
			bit5 = bit5;
		if (bit5==2)
			bit5 = 0;

		//Add one to bit6, if required
		if ((bit1==0)&&(bit2==0)&&(bit3==0)&&(bit4==0)&&(bit5==0))
			bit6 = bit6+1;
		else
			bit6 = bit6;
		if (bit6==2)
			bit6 = 0;

		//Add one to bit7, if required
		if ((bit1==0)&&(bit2==0)&&(bit3==0)&&(bit4==0)&&(bit5==0)&&(bit6==0))
			bit7 = bit7+1;
		else
			bit7 = bit7;
		if (bit7==2)
			bit7 = 0;

		//Add one to bit8, if required
		if ((bit1==0)&&(bit2==0)&&(bit3==0)&&(bit4==0)&&(bit5==0)&&(bit6==0)&&(bit7==0))
			bit8 = bit8+1;
		else
			bit8 = bit8;
		if (bit7==2)
			bit8 = 0;
	}

	// Set Parity bit
	if ((bit1+bit2+bit3+bit4+bit5+bit6+bit7+bit8)%2 == 0)
		parity = 0;
	else
		parity = 1;
}

// Destructor for word that sets all its bits to zero
word::~word()
{
	bit1 = 0;
	bit2 = 0;
	bit3 = 0;
	bit4 = 0;
	bit5 = 0;
	bit6 = 0;
	bit7 = 0;
	bit8 = 0;
	parity = 0;
}

// Define a print function to display binary sequence
void word::Print()
{
	cout << "(" << parity << bit8 << bit7 << bit6 << bit5 << bit4 << bit3 << bit2 << bit1 << ")" << endl;
}

// Define the Check Parity Bit Function
bool word::check_parity_OK()
{
	bool answer;

	if ((parity==0)&&(bit1+bit2+bit3+bit4+bit5+bit6+bit7+bit8)%2 == 0)
	{
		answer = true;
	}

	if ((parity==0)&&(bit1+bit2+bit3+bit4+bit5+bit6+bit7+bit8)%2 != 0)
	{
		answer = false;
	}

	if ((parity==1)&&(bit1+bit2+bit3+bit4+bit5+bit6+bit7+bit8)%2 != 0)
	{
		answer = true;
	}

	if ((parity==1)&&(bit1+bit2+bit3+bit4+bit5+bit6+bit7+bit8)%2 == 0)
	{
		answer = false;
	}
	
	if (answer == true)
		cout << "Parity OK?: " << "Yes" << endl;
	else
		cout << "Parity OK?: " << "No" << endl;

	return answer;
}

// Define the Digital to Analogue Converter Function
int word::DAC()
{
	int value;

	if (bit8 == 0)
	{
		cout << "The word is a positive integer" << endl;

		//Calculate the decimal equivalent of the binary word
		value = (bit8*pow(2.0,7.0))+(bit7*pow(2.0,6.0))+(bit6*pow(2.0,5.0))+(bit5*pow(2.0,4.0))+(bit4*pow(2.0,3.0))+(bit3*pow(2.0,2.0))+(bit2*pow(2.0,1.0))+(bit1*pow(2.0,0.0));
	}
	else
	{
		cout << "The word is a negative integer" << endl;

		//Convert to the decimal equivalent of the binary word
		//First, invert the bits
		//Invert bit1
		if (bit1==0)
			bit1 = 1;
		else
			bit1 = 0;

		//Invert bit2
		if (bit2==0)
			bit2 = 1;
		else
			bit2 = 0;

		//Invert bit3
		if (bit3==0)
			bit3 = 1;
		else
			bit3 = 0;

		//Invert bit4
		if (bit4==0)
			bit4 = 1;
		else
			bit4 = 0;

		//Invert bit5
		if (bit5==0)
			bit5 = 1;
		else
			bit5 = 0;

		//Invert bit6
		if (bit6==0)
			bit6 = 1;
		else
			bit6 = 0;

		//Invert bit7
		if (bit7==0)
			bit7 = 1;
		else
			bit7 = 0;

		//Invert bit8
		if (bit8==0)
			bit8 = 1;
		else
			bit8 = 0;

		//Second, Add one to the inverted binary word
		//Add one to bit1
		if ((bit1+1)==2)
			bit1 = 0;
		else
			bit1 = 1;

		//Add one to bit2, if required
		if (bit1==0)
			bit2 = bit2+1;
		else
			bit2 = bit2;
		if (bit2==2)
			bit2 = 0;

		//Add one to bit3, if required
		if ((bit1==0)&&(bit2==0))
			bit3 = bit3+1;
		else
			bit3 = bit3;
		if (bit3==2)
			bit3 = 0;

		//Add one to bit4, if required
		if ((bit1==0)&&(bit2==0)&&(bit3==0))
			bit4 = bit4+1;
		else
			bit4 = bit4;
		if (bit4==2)
			bit4 = 0;

		//Add one to bit5, if required
		if ((bit1==0)&&(bit2==0)&&(bit3==0)&&(bit4==0))
			bit5 = bit5+1;
		else
			bit5 = bit5;
		if (bit5==2)
			bit5 = 0;

		//Add one to bit6, if required
		if ((bit1==0)&&(bit2==0)&&(bit3==0)&&(bit4==0)&&(bit5==0))
			bit6 = bit6+1;
		else
			bit6 = bit6;
		if (bit6==2)
			bit6 = 0;

		//Add one to bit7, if required
		if ((bit1==0)&&(bit2==0)&&(bit3==0)&&(bit4==0)&&(bit5==0)&&(bit6==0))
			bit7 = bit7+1;
		else
			bit7 = bit7;
		if (bit7==2)
			bit7 = 0;

		//Add one to bit8, if required
		if ((bit1==0)&&(bit2==0)&&(bit3==0)&&(bit4==0)&&(bit5==0)&&(bit6==0)&&(bit7==0))
			bit8 = bit8+1;
		else
			bit8 = bit8;
		if (bit7==2)
			bit8 = 0;

		//Calculate the decimal equivalent of the binary word
		value = -1*((bit8*pow(2.0,7.0))+(bit7*pow(2.0,6.0))+(bit6*pow(2.0,5.0))+(bit5*pow(2.0,4.0))+(bit4*pow(2.0,3.0))+(bit3*pow(2.0,2.0))+(bit2*pow(2.0,1.0))+(bit1*pow(2.0,0.0)));
	}

	return value;
}

// Define the class for Binary Sequence
class bin_seq
{
	private:
		int bits_for_word;

	public:
		bin_seq();
		~bin_seq();
		friend bin_seq get_all_bits();
};

bin_seq::bin_seq()
{

}

// Define the class for message
class message
{
	private:
		int a_word;

	public:
		message(int *words);
		message();
		~message();
		bin_seq get_all_bits();
};

message::message(int *words)
{

}

int main ()
{
	int ans1 = 112;
	int ans2 = -75;
	bool logic1, logic2;
	int result1, result2;

	word voltage;
	voltage.Print();

	word check1(ans1);
	check1.Print();
	logic1 = check1.check_parity_OK();
	//cout << logic1 << endl;
	result1 = check1.DAC();
	cout << result1 << endl;

	cout << endl;

	word check2(ans2);
	check2.Print();
	logic2 = check2.check_parity_OK();
	//cout << logic2 << endl;
	result2 = check2.DAC();
	cout << result2 << endl;

	cin.sync();
	cin.get();
	return 0;
}

[3hM2Nwbp]

You might want to check out the bitset class.

http://www.cplusplus.com/reference/stl/bitset/

[anthony1947]

Hello Luc Lieber,

Thanks for this suggestion. I believe I can use this to optimise my method for encoding the decimal numbers in binary/two's complement format.

Have you got any suggestions as to how I can implement the binary sequence by using the class bin_seq to concatenate the binary/two's complement form of the decimal numbers?