class Packet:
'''
FI - frame info
DA - destination Address
SA - source address
M - monitor bit
A - address recognized bit
C - frame-copied bit
'''
def __init__(self,frame = None):
self.bitStuffing = bit_stuffing()
self.hamming = Hamming()
self.frame = frame
if not frame:
self.FI = bitarray(8)
self.FI.setall(False)
self.DA = None
self.SA= None
else:
self.extractFrameInfo()
@property
def Frame(self):
return self.frame
@Frame.setter
def Frame(self,frame):
self.frame = frame
self.extractFrameInfo()
@property
def monitor(self):
return self.FI[2]
@monitor.setter
def monitor(self,value):
self.FI[2] = value
@property
def addrRecognized(self):
return self.FI[1]
@addrRecognized.setter
def addrRecognized(self,value):
self.FI[1] = value
@property
def frameCopied(self):
return self.FI[0]
@frameCopied.setter
def frameCopied(self,value):
self.FI[0] = value
def pack(self,payload):
#bit stuffing
payload,pBitStuffed = self.bitStuffing.encode(payload)
#hamming encode
payload = self.hamming.encode(payload)
# packet = FD + FI + DA + SA + payload + FD
FD = self.bitStuffing.byteFD
packet = FD + self.FI.tobytes() + self.DA.to_bytes(1,byteorder = 'big') + self.SA.to_bytes(1,byteorder = 'big') + payload + FD
self.frame = packet
return self.frame
def repack(self):
FD = self.bitStuffing.byteFD
self.frame = FD + self.FI.tobytes() + self.DA.to_bytes(1,byteorder = 'big') + self.SA.to_bytes(1,byteorder = 'big') + self.frame[4:len(self.frame)-1] + FD
def extractFrameInfo(self):
self.FI = bitarray()
self.FI.frombytes(self.frame[1:2])
self.DA = int.from_bytes(self.frame[2:3],byteorder='big')
self.SA = int.from_bytes(self.frame[3:4],byteorder='big')
def unpack(self):
payload = self.frame[4 : len(self.frame)-1]
#hemming decode
payload = self.hamming.decode(bytes(payload))
#bit stuffing decode
payload,pBitStuffed = self.bitStuffing.decode(payload)
return payload
class Packet:
'''
FI - frame info - 8 bit
DA - destination Address - 6 byte
SA - source address - 6 byte
M - monitor bit
A - address recognized bit
C - frame-copied bit
'''
# packet = FD + FI + DA + SA + payload + FD
def __init__(self,frame = None):
self.bitStuffing = bit_stuffing()
self.hamming = Hamming()
self.frame = frame
self.fi_size = 8 #bit
self.addr_size = 6 #byte
self.fi_pos = 1
self.da_pos = 2
self.sa_pos = 8
self.payload_pos = 14
self.da_addr = None
self.sa_addr = None
if not frame:
self.FI = bitarray(self.fi_size)
self.FI.setall(False)
self.b_DA = None
self.b_SA= None
else:
self.extractFrameInfo()
@property
def Frame(self):
return self.frame
@Frame.setter
def Frame(self,frame):
self.frame = frame
self.extractFrameInfo()
@property
def monitor(self):
return self.FI[2]
@monitor.setter
def monitor(self,value):
self.FI[2] = value
@property
def addrRecognized(self):
return self.FI[1]
@addrRecognized.setter
def addrRecognized(self,value):
self.FI[1] = value
@property
def frameCopied(self):
return self.FI[0]
@frameCopied.setter
def frameCopied(self,value):
self.FI[0] = value
@property
def da(self):
return self.da_addr
@da.setter
def da(self,addr):
self.da_addr = addr
self.b_DA = self.addrToBytes(addr)
@property
def sa(self):
return self.sa_addr
@sa.setter
def sa(self,addr):
self.sa_addr = addr
self.b_SA = self.addrToBytes(addr)
def pack(self,payload):
#bit stuffing
payload,pBitStuffed = self.bitStuffing.encode(payload)
#hamming encode
payload = self.hamming.encode(payload)
# packet = FD + FI + DA + SA + payload + FD
b_FD = self.bitStuffing.byteFD
packet = b_FD + self.FI.tobytes() + self.b_DA + self.b_SA + payload + b_FD
self.frame = packet
return self.frame
def repack(self):
b_FD = self.bitStuffing.byteFD
self.frame = b_FD + self.FI.tobytes() + self.b_DA + self.b_SA + self.frame[self.payload_pos : len(self.frame)-1] + b_FD
def extractFrameInfo(self):
self.FI = bitarray()
self.FI.frombytes(self.frame[ self.fi_pos : self.fi_pos + 1 ])
self.b_DA = self.frame[self.da_pos : self.da_pos + self.addr_size]
self.b_SA = self.frame[self.sa_pos : self.sa_pos + self.addr_size]
self.da_addr = self.addrFromBytes(self.b_DA)
self.sa_addr = self.addrFromBytes(self.b_SA)
def unpack(self):
payload = self.frame[self.payload_pos : len(self.frame)-1]
#hemming decode
payload = self.hamming.decode(bytes(payload))
#bit stuffing decode
payload,pBitStuffed = self.bitStuffing.decode(payload)
return payload
def addrToBytes(self,addr):
#4 + 2 bytes ASCII
ip,port = addr
str_quartet = ip.split('.')
num_quartet = [int(byte) for byte in str_quartet]
byte_quartet = [el.to_bytes(1,byteorder='big') for el in num_quartet]
num_port = int(port)
return b''.join(byte_quartet) + num_port.to_bytes(2,byteorder='big')
def addrFromBytes(self,bAddr):
int_quartet = list(bAddr[:4])
port = int.from_bytes(bAddr[4:],byteorder='big')
IP = '.'.join([str(el) for el in int_quartet])
return (IP,str(port))
class Packet:
'''
FI - frame info - 8 bit
DA - destination Address - 6 byte
SA - source address - 6 byte
M - monitor bit
A - address recognized bit
C - frame-copied bit
'''
# packet = FD + FI + DA + SA + payload + FD
def __init__(self, frame=None):
self.bitStuffing = bit_stuffing()
self.hamming = Hamming()
self.frame = frame
self.fi_size = 8 #bit
self.addr_size = 6 #byte
self.fi_pos = 1
self.da_pos = 2
self.sa_pos = 8
self.payload_pos = 14
self.da_addr = None
self.sa_addr = None
if not frame:
self.FI = bitarray(self.fi_size)
self.FI.setall(False)
self.b_DA = None
self.b_SA = None
else:
self.extractFrameInfo()
@property
def Frame(self):
return self.frame
@Frame.setter
def Frame(self, frame):
self.frame = frame
self.extractFrameInfo()
@property
def monitor(self):
return self.FI[2]
@monitor.setter
def monitor(self, value):
self.FI[2] = value
@property
def addrRecognized(self):
return self.FI[1]
@addrRecognized.setter
def addrRecognized(self, value):
self.FI[1] = value
@property
def frameCopied(self):
return self.FI[0]
@frameCopied.setter
def frameCopied(self, value):
self.FI[0] = value
@property
def da(self):
return self.da_addr
@da.setter
def da(self, addr):
self.da_addr = addr
self.b_DA = self.addrToBytes(addr)
@property
def sa(self):
return self.sa_addr
@sa.setter
def sa(self, addr):
self.sa_addr = addr
self.b_SA = self.addrToBytes(addr)
def pack(self, payload):
#bit stuffing
payload, pBitStuffed = self.bitStuffing.encode(payload)
#hamming encode
payload = self.hamming.encode(payload)
# packet = FD + FI + DA + SA + payload + FD
b_FD = self.bitStuffing.byteFD
packet = b_FD + self.FI.tobytes(
) + self.b_DA + self.b_SA + payload + b_FD
self.frame = packet
return self.frame
def repack(self):
b_FD = self.bitStuffing.byteFD
self.frame = b_FD + self.FI.tobytes(
) + self.b_DA + self.b_SA + self.frame[self.
payload_pos:len(self.frame) -
1] + b_FD
def extractFrameInfo(self):
self.FI = bitarray()
self.FI.frombytes(self.frame[self.fi_pos:self.fi_pos + 1])
self.b_DA = self.frame[self.da_pos:self.da_pos + self.addr_size]
self.b_SA = self.frame[self.sa_pos:self.sa_pos + self.addr_size]
self.da_addr = self.addrFromBytes(self.b_DA)
self.sa_addr = self.addrFromBytes(self.b_SA)
def unpack(self):
payload = self.frame[self.payload_pos:len(self.frame) - 1]
#hemming decode
payload = self.hamming.decode(bytes(payload))
#bit stuffing decode
payload, pBitStuffed = self.bitStuffing.decode(payload)
return payload
def addrToBytes(self, addr):
#4 + 2 bytes ASCII
ip, port = addr
str_quartet = ip.split('.')
num_quartet = [int(byte) for byte in str_quartet]
byte_quartet = [el.to_bytes(1, byteorder='big') for el in num_quartet]
num_port = int(port)
return b''.join(byte_quartet) + num_port.to_bytes(2, byteorder='big')
def addrFromBytes(self, bAddr):
int_quartet = list(bAddr[:4])
port = int.from_bytes(bAddr[4:], byteorder='big')
IP = '.'.join([str(el) for el in int_quartet])
return (IP, str(port))
# -*- coding:utf-8 -*-
import Huffman, Hamming, Channel
#test if function is correct
if __name__ == "__main__":
# Huffman is encoding XD
Huffman.make_code_table("frequency.txt", "huffman_table.out")
Huffman.encode("huffman_table.out", "raw_file.txt", "huffman.out", 4)
# Hamming is encoding ;D
print "=====message with Hamming-coding====="
Hamming.error_flag("error_flag.out")
Hamming.make_code_table("hamming_table.out")
Hamming.encode("hamming_table.out", "huffman.out", "hamming.out")
# message is in the channel
Channel.transmission("hamming.out", "channel.out")
# Hamming is decoding ;D
Hamming.decode("hamming_table.out", "channel.out", "hamming_decode_out_from_channel.out", "error_flag.out")
# Huffman is decoding XD
Huffman.decode("huffman_table.out", "hamming_decode_out_from_channel.out", "huffman_decode_out_from_channel.out")
print "=====message *without* Hamming-coding====="
# message is in the channel
Channel.transmission("hamming.out", "channel.out")
# Huffman is decoding XD
Huffman.decode("huffman_table.out", "channel.out", "huffman_decode_out_from_channel2.out")
print "=====Huffman====="
Huffman.efficiency("huffman_table.out", "frequency.txt")
