Homework SoursePlease take time to answer and produce correct result to the
Please take time to answer and produce correct result to the question.please show resulting code and output on screen The requirement code are shown below.
Grading (100 pts):
You can earn points as you submit you assignment. Namely, marks will be added as you correctly complete the assignment.
1. (15 pts)
1.1. (5 pts)Proper documentation, meaning variables,
1.2. (5 pts) ease of reviewing program
1.3. (5 pts) compiles with no errors and no warnings.
2. (15 pts) Functions in the bit_manipulation.c were correctly coded.
3. (25 pts) Transmit program is correct –
3.1. correctly setting the parity bits
3.2. Providing an example of the input and output of the program
3.3. Providing a transmitReadMe file that describes how to compile and use the program.
4. (45) Receive program is correct –
4.1. Correctly completing the function for error correction
4.2. Correctly completing the function for converting from short integer to char
4.3. Providing an example of the input and output of the program
4.4. Providing a receiveReadMe file that describes how to compile and use the program.
QUESTION
Tasks
In this assignment you will write two short programs that would simulate the transmission a message over a communication line: one program would simulate the transmission of a message (an array of characters) and one that simulate the receiving of a message.
You will use the skeleton in the files transmit.c and receive.c. Helper functions that manipulate bit data should be written in a file bit_manipulation.c
Coding Instructions:
1) Commenting in Code – as provided in the slides given in class
2) No usage of global variables. All data must be passed or received via function parameters.
3) Write short and simple functions.
4) Suggestion – as you code your small helper functions write small test functions to ensure that the code is correct. This will allow you to focus on the logic of your program without worrying about the simple functions.
bit_manipulation file (15 pts)
The file contains some functions that are required by the main programs.
1. Review the functions in the file and their purpose
2. Complete the code for each of the functions.
3. Add other functions as needed
Transmit program (25 pts)
1. (10 pts) Add a function to bit_manipulation.c that takes as input an a short integer num and returns the number of bits that are set to 1. For example if num is 0x9 then the function returns 2. Here you need to declare the function and also add the prototype to the bit_manipulation.h header file.
2. (15 pts) Using the function that you created in 1 above add the code to the setParityBits function.
3. Use the functions in the bit_manipulation.c file
Receive program (45 pts)
The provided code can already read the encoded message that is provided into an array of integers. The program uses the output from the Transmit program as input to the receive program. Using the provided skeleton do the following:
Assignment 2 COMP 2401 Page7 of 7
1. (20 pts) Write a function to collects (unpacks) the bits from the encoded short integer into a character. The function is int short2Char(short encodedChar, char *c) which takes an encodedChar (a short integer) and updates the character with the correct bits. Namely, it maps bits 3,5,6,7,9,10,11,12 of the encodedChar onto bits 0,1,2,3,4,5,6,7 of c. Review the code of the function char2Short() in the Transmit program.
2. (25 pts) Complete the code of correctCode using the function that you coded in step 1 of the Transmit program and the functions in bit_manipulation.c
3. Use the functions in the bit_manipulation.c file
Compiling the programs.
Compile the transmit program
Here we have two files for each program (e.g., transmit.c and bit_manipulation.c). Compiling the program will be as follows:
gcc –o tran transmit.c bit_manipulation.c
Compiling for the debugger will be as follows:
gcc -g –o tran transmit.c bit_manipulation.c
Compile the receive program
Here we have two files for each program (e.g., transmit.c and bit_manipulation.c). Compiling the program will be as follows:
gcc –o recv receive.c bit_manipulation.c
Compiling for the debugger will be as follows:
gcc -g –o recv receive.c bit_manipulation.c
Execution:
a. Start the transmit program. The program will prompt the user to enter a message. The program will then print the transmitted message as a sequence of short integers.
b. Start the receive message. The program will prompt the user to enter the transmitted message. Here you will have to copy the output from transmit program. The program should output the uncorrected transmitted message and the corrected message.
BIT MANIPULATION.C
/*
File bit_manipulation.c
Purpose :
contains helper functions for manipulating bits
Revisions:
file created: Doron Nussbaum
* /
/************************************************************************/
// INCLUDE FILES
#include \"bit_manipulation.h\"
/************************************************************************/
//MACROS / DEFINES
/************************************************************************/
// FUNCTION PROTOTYPES
/***************************************************/
//example of a testing function main();
#if 0
int mainTesting(int argc, char *argv[])
{
int rc = 0; // return code
short test = 0;
short modified;
int bitNum; // bit number to be used
test = 0;
bitNum = 2;
modified = test;
flipBitShort(bitNum, &modified);
printf(\"test_int=%d, flipping bit #=%d, answer should be=%d, test_modified=%d\ \", test, bitNum, 4, modified);
rc = isShortBitSet(modified, 3);
printf(\"Bit 3 in %d should not be set. Answer is %d \ \", modified, rc);
rc = isShortBitSet(modified, 2);
printf(\"Bit 2 in %d should be set. Answer is %d \ \", modified, rc);
getchar();
return(0);
}
#endif
/*************************************************************************************/
/* purpose: checks if bit i is set
input:
c - the character to be checked
bitNum - the bit number to be checked
return:
1 if the bit is set to 1
0 if the bit is not set (bit is 0)
*/
int isCharBitSet(char c, int bitNum)
{
// add code
}
/*************************************************************************************/
/* purpose: checks if bit i is set
input:
num - the number to be checked
bitNum - the bit number to be checked
return:
1 if the bit is set to 1
0 if the bit is not set (bit is 0)
*/
int isShortBitSet(short num, int bitNum)
{
// add code
}
/*************************************************************************************/
/* purpose: sets bit bitNum to 1
input:
num - the address of the short integer
bitNum - the bit number to be checked
*/
void setShortBit(int bitNum, short *num)
{
// add code
}
/*************************************************************************************/
/* purpose: sets bit bitNum to 1
input:
c - address of character
bitNum - the bit number to be checked
return:
1 if the bit is set to 1
0 if the bit is not set (bit is 0)
*/
void setCharBit(int bitNum, char *c)
{
// add code
//
}
/*************************************************************************************/
/* count the number of bits in a short
input:
num - a short interger
return
the numer of bits that are set to 1 in num
*/
int countBits(short num)
{
// add code
}
/*************************************************************************************/
/* purpose:
flips bit i in num (set bit i to 1 if the bit is 0 or set bit i to 0 if the bit is 1)
input:
bitNum - the bit number to be flipped
num - address of the short integer
*/
void flipBitShort(int bitNum, short *num)
{
// add code
}
BIT MANIPULATION.H
/*
File bit_manipulation.h
Purpose:header file of functions prototypes
*/
/************************************************************************/
// INCLUDE FILES
#include \"stdio.h\"
#include \"stdlib.h\"
#include \"assert.h\"
/************************************************************************/
// FUNCTION PROTOTYPES
int isCharBitSet(char c, int bitNum);
void setCharBit(int bitNum, char *c);
int isShortBitSet(short num, int bitNum);
void setShortBit(int bitNum, short *num);
void flipBitShort(int bitNum, short *num);
int countBits(short num);
RECIEVE.C
/*
File receive.c
Purpose: simulate the receiveing end of a message over the network.
The program converts a message encodded as an array of short integers into characters.
The input message uses 1-bit error correction code.
As part of the simulation, the program also corrects any 1-bit errors in the receiving message.
Revision:
a. Initial code - Doron Nussbaum
*/
/************************************************************************/
// INCLUDE FILES
#include \"stdio.h\"
#include \"stdlib.h\"
#include \"string.h\"
#include \"assert.h\"
#include \"bit_manipulation.h\"
/************************************************************************/
//MACROS / DEFINES
#define XSTR(A) STR(A)
#define STR(A) #A
#define MAX_INPUT_LENGTH 8192
#define MAX_MSG_LENGTH 2048
#define P1_MASK 0xaa8 // 0b0101010101000
#define P2_MASK 0xcc8 // 0b0110011001000
#define P4_MASK 0x10e0 // 0b1000011100000
#define P8_MASK 0x1e00 // 0b1111000000000
/************************************************************************/
// FUNCTION PROTOTYPES
void short2Char(short encodedChar, char *c);
void correctCode(short *num);
void readEncodedMessage(short *buf, int len, int *numRead);
/**************************************************************************/
int main(int argc, char *argv[])
{
int rc = 0; // return code
char s[MAX_MSG_LENGTH] = { \'\\0\' }; // message
short encodedMsg[MAX_MSG_LENGTH];
int numRead = 0; // number of characters in the message
int i;
// read the message
printf(\"Please enter the transmitted message: \");
readEncodedMessage(encodedMsg, MAX_MSG_LENGTH, &numRead);
// print the corrected message
printf(\"\ \ Transmitted Message:\ \");
for (i = 0; i < numRead; i++) {
char c;
short2Char(encodedMsg[i], &c);
printf(\"%c\", c);
}
printf(\"\ \");
// correct the message
for (i = 0; i < numRead; i++) {
correctCode(&encodedMsg[i]);
}
// print the corrected message
printf(\"\ \ Corrected Transmitted Message:\ \");
for (i = 0; i < numRead; i++) {
char c;
short2Char(encodedMsg[i], &c);
printf(\"%c\", c);
}
printf(\"\ \");
return(0);
}
/***********************************************************************************/
/* reads a message from the user
input
len - maximum length of mesage that should be read
output
receivedMsg - contains the message
numRead - the number of characters in the message
*/
void readEncodedMessage(short *receivedMsg, int len, int *numRead)
{
int i;
int rc;
char s[MAX_INPUT_LENGTH+1];
char *token = NULL;
*numRead = 0;
s[MAX_INPUT_LENGTH] = \'\\0\';
scanf(\"%\"XSTR(MAX_INPUT_LENGTH)\"[^\ ]s\", s);
token = strtok(s, \" \");
for (i = 0; token != NULL && i < len;token = strtok(NULL, \" \"), i++) {
rc = sscanf(token, \"%hd\", &receivedMsg[i]);
}
*numRead = i; // set the number of read integers
// empty the input buffer
for( ; getchar() != \'\ \'; );
}
/*************************************************************************/
/* collect of a short bits 3,5,6,7,9,10,11,12 to bits 0-7 of a char
input
encodedNum - a short with the bits of c
output
c - the char that is embedded in encodedNum
*/
void short2Char(short encodedNum, char *c)
{
short mask = 0x0001;
int i;
int bitSet;
*c = 0;
for (i = 0; i < 8; i++) {
// set the correct bit in char
// for each bit i do
// if the corrsponding bit in the encodedChar is set
// set the bit at the char c
}
}
/*************************************************************************************/
/* purpose:
performs error corrrections, if needed on the short integer
The function first checks the parity bits for error.
If there is an error then it fixes it.
input
num - the address of the short number
*/
void correctCode(short *num)
{
int mask;
int sum;
int bitNumber = 0; // bit number with the error bit
int parity; // a parity bit either 0 or 1
int storedParity; // the parity bit in the encoded char
// check parity bit p1
// get the bits related to P1 using P1_MASK
// count the bits
// determine if the parity bit should have been set
// get the parity for P1_MASK htat is stored in *num
// compare the calculated parity with the stored parity
// if the two parities are different add 2^0 to bitNumber
// simlilary check parity bit p2
// calculate the parity for P2
// compare the calculated parity with the stored parity
// if the two parities are different add 2^1 to bitNumber
// check parity bit p4
// calculate the parity for P4
// compare the calculated parity with the stored parity
// if the two parities are different add 2^2 to bitNumber
// check parity bit p8
// calculate the parity for P8
// compare the calculated parity with the stored parity
// if the two parities are different add 2^3 to bitNumber
// if necessary flip the bit at position bitNumber
}
TANSMIT.C
/*
File transmit.c
Purpose: simulate a transmission of characters over the network.
It converts a message given as an array of characters to an array of short integers that are sent over the network.
The converted message uses 1-bit error correction code.
As part of the simulation, the program also injects errors to the encoded message by flipping one bit.
Revision:
a. Initial code - Doron Nussbaum
*/
/************************************************************************/
// INCLUDE FILES
#include \"stdio.h\"
#include \"stdlib.h\"
#include \"string.h\"
#include \"assert.h\"
#include \"bit_manipulation.h\"
/************************************************************************/
//MACROS / DEFINES
#define MAX_MSG_LENGTH 2048
#define P1_MASK 0xaa8 // 0b0101010101000
#define P2_MASK 0xcc8 // 0b0110011001000
#define P4_MASK 0x10e0 // 0b1000011100000
#define P8_MASK 0x1e00 // 0b1111000000000
/************************************************************************/
// FUNCTION PROTOTYPES
int readMessage(char *s, int len, int *numRead);
int char2Short(char c, short *encodedChar);
int setParityBits(short *num);
/************************************************************************/
int main(int argc, char *argv[])
{
int rc = 0; // return code
char s[MAX_MSG_LENGTH] = { \'\\0\' }; // message
short encodedMsg[MAX_MSG_LENGTH];
int numRead = 0; // number of characters in the message
int i;
// read the message
printf(\"Please enter a message to transmit: \");
readMessage(s, MAX_MSG_LENGTH, &numRead);
// encode the message
for (i = 0; i < numRead; i++) {
char2Short(s[i], &encodedMsg[i]); // embedd the char in a short int
setParityBits(&encodedMsg[i]); // set the parity bits
}
// add errors to mesage
for (i = 0; i < numRead; i++) {
if (rand()%36000 < 25000) {
int bit = rand() % 13;
flipBitShort(bit, &encodedMsg[i]);
}
}
// print the message
printf(\"\ \ Transmitted message (short integers):\ \");
for (i = 0; i < numRead; i++) {
printf(\"%d \", encodedMsg[i]);
}
printf(\"\ \");
return(0);
}
/***********************************************************************************/
/* reads a message from the user
input
len - maximum length of mesage that should be read
output
s - contains the message
numRead - the number of characters in the message
assumption - s is valid
*/
int readMessage(char *s, int len, int *numRead)
{
int i;
int rc = 1;
*numRead = 0;
for (i = 0; i < len, rc != 0; i++) {
rc = scanf(\"%c\", &s[i]);
if (s[i] == \'\ \') break;
(*numRead)++;
}
return(0);
}
/*************************************************************************/
/* spreads bits 0-7 of the character c into bits 3,5,6,7,9,10,11,12 of the short encodedChar
input
character c
output
encodedChar - a short with the bits of c
*/
int char2Short(char c, short *encodedChar)
{
short mask = 0x0001;
int i;
int bitSet;
*encodedChar = 0;
for (i = 0; i < 8; i++) {
// check if bit i is set
bitSet = isCharBitSet(c, i);
// set the correct bit in the encoded character
if (!bitSet) continue;
switch (i) {
case 0:
setShortBit(3, encodedChar);
break;
case 1:
case 2:
case 3:
setShortBit(4 + i, encodedChar);
break;
case 4:
case 5:
case 6:
case 7:
setShortBit(5 + i, encodedChar);
break;
default:
printf(\"This should not happen !!!!\ \");
assert(0);
}
}
return(0);
}
/*************************************************************************************/
/* sets the parity bits in the variable num
input
num - the short numbe where parithy bits must be set
*/
int setParityBits(short *num)
{
int mask;
int sum;
// set parity bit p1
// get the bits covered by the mask
// count the number of bits
// if the numbef of bits is odd then set the parity bit P1
// set parity bit p2
// get the bits covered by the mask for P2
// count the numbefr of bits and set the parity of P2
// set parity bit p4
// get the bits covered by the mask for P4
// count the numbefr of bits and set the parity of P4
// set parity bit p8
// count the numbefr of bits and set the parity of P8
return(0);
}
Solution
transmit.c
#include \"stdio.h\"
#include \"stdlib.h\"
#include \"string.h\"
#include \"assert.h\"
#include \"bit_manipulation.h\"
/************************************************************************/
//MACROS / DEFINES
#define MAX_MSG_LENGTH 2048
#define P1_MASK 0xaa8 // 0b0101010101000
#define P2_MASK 0xcc8 // 0b0110011001000
#define P4_MASK 0x10e0 // 0b1000011100000
#define P8_MASK 0x1e00 // 0b1111000000000
/* The following are ANSI Escape Sequences.
* You can find more by typing: man terminfo
* The exact ones under can be found on stackoverflow here:
* http://stackoverflow.com/questions/3219393/stdlib-and-colored-output-in-c
*/
#define ANSI_COLOR_RED \"\\x1b[31;1m\"
#define ANSI_COLOR_GREEN \"\\x1b[32;1m\"
#define ANSI_COLOR_YELLOW \"\\x1b[33;1m\"
#define ANSI_COLOR_BLUE \"\\x1b[34;1m\"
#define ANSI_COLOR_MAGENTA \"\\x1b[35;1m\"
#define ANSI_COLOR_CYAN \"\\x1b[36;1m\"
#define ANSI_BACK_BLACK \"\\x1b[31;1m\"
#define ANSI_COLOR_RESET \"\\x1b[0m\"
#define CLEAR \"\\033[2J\"
/************************************************************************/
// FUNCTION PROTOTYPES
int readMessage(char *s, int len, int *numRead);
int char2Short(char c, short *encodedChar);
int setParityBits(short *num);
/************************************************************************/
int main(int argc, char *argv[])
{
int rc = 0; // return code
char s[MAX_MSG_LENGTH] = { \'\\0\' }; // message
short encodedMsg[MAX_MSG_LENGTH];
int numRead = 0; // number of characters in the message
int i;
// read the message
printf(ANSI_COLOR_CYAN \"Transmit Program written in C\ \" ANSI_COLOR_RESET);
printf(\"\ Hamming Code Implementation v1.0.0 by Mohamad Yassine\ \");
printf(
ANSI_COLOR_RED
\"After running this program, please copy the output and run \ \"
\"the receive program \"
ANSI_COLOR_GREEN
\"./recv .\ \ \"
ANSI_COLOR_RESET);
printf(\"Please enter a message to transmit: \");
readMessage(s, MAX_MSG_LENGTH, &numRead);
// encode the message
for (i = 0; i < numRead; i++) {
char2Short(s[i], &encodedMsg[i]); // embedd the char in a short int
setParityBits(&encodedMsg[i]); // set the parity bits
}
// add errors to mesage
for (i = 0; i < numRead; i++) {
if (rand()%36000 < 25000) {
int bit = rand() % 13;
flipBitShort(bit, &encodedMsg[i]);
}
}
// print the message
printf(\"\ Transmitted message (short integers):\ \ \\t\" ANSI_COLOR_RED);
for (i = 0; i < numRead; i++) {
printf(\"%d \", encodedMsg[i]);
}
printf(ANSI_COLOR_RESET \"\ \ \");
return(0);
}
/***********************************************************************************/
/* reads a message from the user
input
len - maximum length of mesage that should be read
output
s - contains the message
numRead - the number of characters in the message
assumption - s is valid
*/
int readMessage(char *s, int len, int *numRead)
{
int i;
int rc = 1;
*numRead = 0;
for (i = 0; i < len, rc != 0; i++) {
rc = scanf(\"%c\", &s[i]);
if (s[i] == \'\ \') break;
(*numRead)++;
}
return(0);
}
/*************************************************************************/
/* spreads bits 0-7 of the character c into bits 3,5,6,7,9,10,11,12 of the short encodedChar
input
character c
output
encodedChar - a short with the bits of c
*/
int char2Short(char c, short *encodedChar)
{
short mask = 0x0001;
int i;
int bitSet;
*encodedChar = 0;
for (i = 0; i < 8; i++) {
// check if bit i is set
bitSet = isCharBitSet(c, i);
// set the correct bit in the encoded character
if (!bitSet) continue;
switch (i) {
case 0:
setShortBit(3, encodedChar);
break;
case 1:
case 2:
case 3:
setShortBit(4 + i, encodedChar);
break;
case 4:
case 5:
case 6:
case 7:
setShortBit(5 + i, encodedChar);
break;
default:
printf(\"This should not happen !!!!\ \");
assert(0);
}
}
return(0);
}
/*************************************************************************************/
/* sets the parity bits in the variable num
input
num - the short number where parithy bits must be set
*/
int setParityBits(short *num)
{
int mask;
int sum;
/*
* Set parity bits p1 p2 p4 p8
* Summary:
* 1 - Apply the MASK using the AND operand
* 2 - Count the bits that are the result of the AND
* 3 - Find if ODD or Even
* - ODD : If it was ODD (sum % 2 isn\'t 0) then
* We have to set that bit to 1 to make
* it even.
* - EVEN: Do nothing.
* 4 - Done.
* */
if (compareBits(2, P1_MASK, *num)) setShortBit(1, num);
if (compareBits(2, P2_MASK, *num)) setShortBit(2, num);
if (compareBits(2, P4_MASK, *num)) setShortBit(4, num);
if (compareBits(2, P8_MASK, *num)) setShortBit(8, num);
return(0);
}
bit_manipulation.h
/*
File bit_manipulation.h
Purpose:header file of functions prototypes
*/
/************************************************************************/
// INCLUDE FILES
#include \"stdio.h\"
#include \"stdlib.h\"
#include \"assert.h\"
/************************************************************************/
// FUNCTION PROTOTYPES
int isCharBitSet(char c, int bitNum);
void setCharBit(int bitNum, char *c);
int isShortBitSet(short num, int bitNum);
void setShortBit(int bitNum, short *num);
void flipBitShort(int bitNum, short *num);
int countBits(short num);
int compareBits(short modular, short mask, short num);
bit_manipulation.c
/************************************************************************/
// INCLUDE FILES
#include \"bit_manipulation.h\"
/************************************************************************/
//MACROS / DEFINES
/************************************************************************/
// FUNCTION PROTOTYPES
/***************************************************/
//example of a testing function main();
#if 0
int main(int argc, char *argv[])
{
int rc = 0; // return code
short test = 0;
short modified;
int bitNum; // bit number to be used
test = 0;
bitNum = 2;
modified = test;
flipBitShort(bitNum, &modified);
printf(\"test_int=%d, flipping bit #=%d, answer should be=%d, test_modified=%d\ \"
, test, bitNum, 4, modified);
rc = isShortBitSet(modified, 3);
printf(\"Bit 3 in %d should not be set. Answer is %d \ \", modified, rc);
rc = isShortBitSet(modified, 2);
printf(\"Bit 2 in %d should be set. Answer is %d \ \", modified, rc);
getchar();
return(0);
}
#endif
/*************************************************************************************/
/* purpose: checks if bit i is set
input:
c - the character to be checked
bitNum - the bit number to be checked
return:
1 if the bit is set to 1
0 if the bit is not set (bit is 0)
*/
int isCharBitSet(char c, int bitNum) {
return ((c >> bitNum) & 1);
}
/*************************************************************************************/
/* purpose: checks if bit i is set
input:
num - the number to be checked
bitNum - the bit number to be checked
return:
1 if the bit is set to 1
0 if the bit is not set (bit is 0)
*/
int isShortBitSet(short num, int bitNum)
{
/* ADDED JAN 26 19:30 */
return (num >> bitNum) & 1;
}
/*************************************************************************************/
/* purpose: sets bit bitNum to 1
input:
num - the address of the short integer
bitNum - the bit number to be checked
*/
void setShortBit(int bitNum, short *num) {
/* Checks if the bit is 0 and changes it, if not then keeps it the same. */
*num = *num | 1 << bitNum;
}
/*************************************************************************************/
/* purpose: sets bit bitNum to 1
input:
c - address of character
bitNum - the bit number to be checked
return:
1 if the bit is set to 1
0 if the bit is not set (bit is 0)
*/
void setCharBit(int bitNum, char *c)
{
//*c = (*c >> bitNum) & 1;
*c = *c | (1 << bitNum);
}
/*************************************************************************************/
/* count the number of bits in a short
input:
num - a short interger
return
the numer of bits that are set to 1 in num
*/
int countBits(short num)
{
/* Logic:
* 0x9 = 1001 | 2 bits set to 1
* 0x11 = 1011 | 3 bits set to 1
*/
int total = 0;
int atNow = 0;
int i;
for (i = 0; i < 16; i++) {
atNow = isCharBitSet(num, i);
if (atNow) total++;
}
// if (isShortBitSet(num, i) == 1) total++;
return total;
}
/*************************************************************************************/
/* purpose:
flips bit i in num (set bit i to 1 if the bit is 0 or set bit i to 0 if the bit is 1)
input:
bitNum - the bit number to be flipped
num - address of the short integer
*/
void flipBitShort(int bitNum, short *num)
{
/* Flip the bit at i */
*num ^= 1 << bitNum;
return;
}
/*****************************************************************************/
/*
* Compare the bits between the already known masks (P1_MASK, P2_MASK ..etc )
* Comparing usind AND operation, if there is a match then increment sum
*
* Input :
* short modular : the number to use when modulating
* short mask : the given masks
* short num : user provided short
* Output :
* the modular of the sum
*/
int compareBits(short modular, short mask, short num) {
int sum = 0;
for (int i = 0; i < sizeof(mask)*8; i++)
if (isShortBitSet(num, i) & isShortBitSet(mask, i))
sum += 1;
return sum % modular;
}
receive.c
// INCLUDE FILES
#include \"stdio.h\"
#include \"stdlib.h\"
#include \"string.h\"
#include \"assert.h\"
#include \"bit_manipulation.h\"
/************************************************************************/
//MACROS / DEFINES
#define XSTR(A) STR(A)
#define STR(A) #A
#define MAX_INPUT_LENGTH 8192
#define MAX_MSG_LENGTH 2048
#define P1_MASK 0xaa8 // 0b0101010101000
#define P2_MASK 0xcc8 // 0b0110011001000
#define P4_MASK 0x10e0 // 0b1000011100000
#define P8_MASK 0x1e00 // 0b1111000000000
/* The following are ANSI Escape Sequences.
* You can find more by typing: man terminfo
* The exact ones under can be found on stackoverflow here:
* http://stackoverflow.com/questions/3219393/stdlib-and-colored-output-in-c
*/
#define ANSI_COLOR_RED \"\\x1b[31;1m\"
#define ANSI_COLOR_GREEN \"\\x1b[32;1m\"
#define ANSI_COLOR_YELLOW \"\\x1b[33;1m\"
#define ANSI_COLOR_BLUE \"\\x1b[34;1m\"
#define ANSI_COLOR_MAGENTA \"\\x1b[35;1m\"
#define ANSI_COLOR_CYAN \"\\x1b[36;1m\"
#define ANSI_BACK_BLACK \"\\x1b[31;1m\"
#define ANSI_COLOR_RESET \"\\x1b[0m\"
#define CLEAR \"\\033[2J\"
/************************************************************************/
// FUNCTION PROTOTYPES
void short2Char(short encodedChar, char *c);
void correctCode(short *num);
void readEncodedMessage(short *buf, int len, int *numRead);
/**************************************************************************/
int main(int argc, char *argv[])
{
int rc = 0; // return code
char s[MAX_MSG_LENGTH] = { \'\\0\' }; // message
short encodedMsg[MAX_MSG_LENGTH];
int numRead = 0; // number of characters in the message
int i;
// read the message
printf(ANSI_COLOR_CYAN\"Receive Program written in C\ \"ANSI_COLOR_RESET);
printf(\"\ Hamming Code Implementation v1.0.0 by Mohamad Yassine\ \");
printf(
ANSI_COLOR_RED
\"If you have not already, please run \"
ANSI_COLOR_GREEN
\"./tran \"
ANSI_COLOR_RED
\"to generate a message.\ \ \"
ANSI_COLOR_RESET);
printf(\"Please enter the transmitted message: \");
readEncodedMessage(encodedMsg, MAX_MSG_LENGTH, &numRead);
// print the corrected message
printf(\"\ \ Transmitted Message:\ \ \\t\" ANSI_COLOR_BLUE);
for (i = 0; i < numRead; i++) {
char c;
short2Char(encodedMsg[i], &c);
printf(\"%c\", c);
}
printf(\"\ \");
// correct the message
for (i = 0; i < numRead; i++) {
correctCode(&encodedMsg[i]);
}
// print the corrected message
printf(ANSI_COLOR_RESET);
printf(\"\ \ Corrected Transmitted Message:\ \ \\t \" ANSI_BACK_BLACK);
for (i = 0; i < numRead; i++) {
char c;
short2Char(encodedMsg[i], &c);
printf(\"%c\", c);
}
printf(ANSI_COLOR_RESET\" \ \ \");
return(0);
}
/***********************************************************************************/
/* reads a message from the user
input
len - maximum length of mesage that should be read
output
receivedMsg - contains the message
numRead - the number of characters in the message
*/
void readEncodedMessage(short *receivedMsg, int len, int *numRead)
{
int i;
int rc;
char s[MAX_INPUT_LENGTH+1];
char *token = NULL;
*numRead = 0;
s[MAX_INPUT_LENGTH] = \'\\0\';
scanf(\"%\"XSTR(MAX_INPUT_LENGTH)\"[^\ ]s\", s);
token = strtok(s, \" \");
for (i = 0; token != NULL && i < len;token = strtok(NULL, \" \"), i++) {
rc = sscanf(token, \"%hd\", &receivedMsg[i]);
}
*numRead = i; // set the number of read integers
// empty the input buffer
for( ; getchar() != \'\ \'; );
}
/*************************************************************************/
/* collect of a short bits 3,5,6,7,9,10,11,12 to bits 0-7 of a char
input
encodedNum - a short with the bits of c
output
c - the char that is embedded in encodedNum
*/
// FROM TO
void short2Char(short encodedNum, char *c)
{
short mask = 0x0001;
int i;
int bitSet;
int k;
*c = 0;
for (i = 0; i < 8; i++) {
// Reaching into bit positions 3,5,6,7,9,10,11,12
if (i == 0) k = 3;
if (i > 0 && i < 4) k = 4 + i;
if (i > 3 && i < 8) k = 5 + i;
// Checking if bit at k is set aka == 1
bitSet = isShortBitSet( encodedNum, k);
// if bit is 0.skip setCharBit and increment i
if (bitSet == 0) continue;
// Set the correct bit in the decoded char
setCharBit(i, c);
}
}
/*************************************************************************************/
/* purpose:
performs error corrrections, if needed on the short integer
The function first checks the parity bits for error.
If there is an error then it fixes it.
input
num - the address of the short number
*/
void correctCode(short *num)
{
int mask;
int sum;
int bitNumber = 0; // bit number with the error bit
int parity; // a parity bit either 0 or 1
int storedParity; // the parity bit in the encoded char
// check parity bit p1
// get the bits related to P1 using P1_MASK
// Get the set default parity
parity = 0;
storedParity = isShortBitSet(*num, 1);
if (compareBits(2, P1_MASK, *num)) parity = 1;
// Comapring before and now (checking if an error occured)
if (storedParity != parity) bitNumber += 1;
// Do the same for the rest
parity = 0;
storedParity = isShortBitSet(*num, 2);
if (compareBits(2, P2_MASK, *num)) parity = 1;
if (storedParity != parity) bitNumber += 2;
parity = 0;
storedParity = isShortBitSet(*num, 4);
if (compareBits(2, P4_MASK, *num)) parity = 1;
if (storedParity != parity) bitNumber += 4;
parity = 0;
storedParity = isShortBitSet(*num, 8);
if (compareBits(2, P8_MASK, *num)) parity = 1;
if (storedParity != parity) bitNumber += 8;
// Flip incorrect bit
flipBitShort(bitNumber, num);
return;
}
