- Trending Categories
Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Bit Stuffing error detection technique using Java
Bit stuffing is a technique used in data communication systems to detect and correct errors that may occur during the transmission of data. It works by adding extra bits to the data being transmitted in order to flag when an error has occurred.
One common way to implement bit stuffing in Java is to use a flag byte (such as 0x7E) to indicate the start and end of a frame, and to use a special escape byte (such as 0x7D) to indicate that the next byte is a stuffed bit. For example, the sender would add a stuffed bit before every occurrence of the flag byte within the data being transmitted, so that the flag byte will not be mistaken for the start or end of a frame at the receiver.
Here's an example of how you could implement bit stuffing in Java −
public static byte[] bitStuff(byte[] data) {
final byte FLAG = 0x7E;
final byte ESCAPE = 0x7D;
// Create a new byte array to store the stuffed data
byte[] stuffedData = new byte[data.length * 2];
// Keep track of the current index in the stuffed data array
int stuffedIndex = 0;
// Iterate through the original data
for (int i = 0; i < data.length; i++) {
byte b = data[i];
// If the current byte is the flag or escape byte, stuff it
if (b == FLAG || b == ESCAPE) {
stuffedData[stuffedIndex++] = ESCAPE;
stuffedData[stuffedIndex++] = (byte) (b ^ 0x20);
} else {
stuffedData[stuffedIndex++] = b;
}
}
return stuffedData;
}
At the receiver side , you can use the similar concept to retrieve the original data.
public static byte[] bitUnStuff(byte[] data) {
final byte FLAG = 0x7E;
final byte ESCAPE = 0x7D;
// Create a new byte array to store the unstuffed data
byte[] unstuffedData = new byte[data.length];
// Keep track of the current index in the unstuffed data array
int unstuffedIndex = 0;
// Iterate through the stuffed data
for (int i = 0; i < data.length; i++) {
byte b = data[i];
// If the current byte is the escape byte, unstuff the next byte
if (b == ESCAPE) {
unstuffedData[unstuffedIndex++] = (byte) (data[++i] ^ 0x20);
} else {
unstuffedData[unstuffedIndex++] = b;
}
}
return unstuffedData;
}
This is a basic example of bit stuffing technique, It can be enhanced to handle more error cases and also validate the data using CRC or Checksum.
Example
Sure! Here's an example of how you could use the bitStuff() and bitUnStuff() methods in a simple program −
public static void main(String[] args) {
byte[] data = {0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x7E}; // Hello~
byte[] stuffedData = bitStuff(data);
System.out.println("Original Data: "+Arrays.toString(data));
System.out.println("Stuffed Data: "+ Arrays.toString(stuffedData));
byte[] unstuffedData = bitUnStuff(stuffedData);
System.out.println("Unstuffed Data: "+ Arrays.toString(unstuffedData));
}
When you run this program, it will first call the bitStuff() method to stuff the original data, then print out the original data and the stuffed data.
Then it will call the bitUnStuff() method to retrieve the original data, then it will print the unstuffed data.
Example
For the given example of data
0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x7E,
Output
You will get the output as
Original Data: [72, 101, 108, 108, 111, 126] Stuffed Data: [72, 101, 108, 108, 111, 93, 30, 126] Unstuffed Data: [72, 101, 108, 108, 111, 126]
You can see the stuffed data has an extra byte 93, 30 which is the stuffed version of 7E.
Also you can see the unstuffed data is same as the original data, which confirms that the data is retrived successfully without any errors.
604 Views
