def get_message(self):
t0 = time.time()
ret_rxmsg = None
if self.rx_buffer.available() >= MessageReceiver.TAIL_LEN:
self.mutex.lock()
peek_buff = self.rx_buffer.peek()
check_tail_result = self.check_tail(peek_buff)
self.mutex.unlock()
if check_tail_result:
_id, _context, _msg_len, _crc, tail_start_mark_pos, tail_end_mark_pos = check_tail_result
self.mutex.lock()
msg_body = self.rx_buffer.read(tail_end_mark_pos + 1 + 2)
self.mutex.unlock()
msg_body = msg_body[:tail_start_mark_pos]
MessageReceiver.ts = time.time()
crc_check = RxMessage.RxId.ack if _crc == crc(msg_body) else RxMessage.RxId.nack
rxmsg = RxMessage(msg_id=_id, crc_check=crc_check, length=len(msg_body), context=_context, body=msg_body)
m_logger.debug(MSG_RX_DBG_TEMPLATE.format(rxmsg))
self.t0 = time.time()
if _crc == crc(msg_body):
self.__mean_rx_time.count(time.time() - t0)
ret_rxmsg = rxmsg
m_logger.debug("Mean msg extract time: {}".format(self.__mean_rx_time))
m_logger.debug("Period: {}".format(time.time() - self.t0))
return ret_rxmsg
def write_flash(self, _file):
_bin, num_of_bytes = self.binary_parser.read_binary_file(_file)
if num_of_bytes == self.eeprom_siz:
self.communicate("Transmitting file")
self.initilize_write_process()
buff_siz = 1024*2
t0 = time.time()
tmp_cnt = 0
for k in range(0, num_of_bytes, buff_siz):
page = _bin[k:k+buff_siz]
_crc = crc.crc(page)
self._emulator.send(page+_crc)
try:
while self._emulator.recv(1) != '.':
pass
except:
popup_window.warning_box("Something went wrong.\n"
"Operation cancelled", "!!!")
return
tmp_cnt += 1
self.progress_signal(100 * (k + buff_siz) / num_of_bytes)
self.verify_crc_with_feedback(_bin, buff_siz)
self.communicate("Elapsed time {}".format(time.time() - t0))
else:
msg = "File size is wrong. \n" \
"Not 27256 EEPROM image !"
detailed_message = "File size: {} bytes\n" \
"expected size: {} bytes".format(num_of_bytes, self.eeprom_siz)
self.communicate(msg)
popup_window.warning_box(msg, detailed_msg= detailed_message, title="Operation cancelled!")
def create_message(msg_id, body, context=0, max_packet_size=MAX_PACKET_SIZE, fail_crc_factor=None):
"""
Create message with name, body_len, crc, id
fail_crc_factor: propability factor to fail crc, value 4 means that 1 of 4 transmissions will fail crc, overwrites fail_crc
:param msg_id: msg id
:param context: msg context
:param body:
:param max_packet_size:
:param fail_crc_factor: fail factor for testing purposes
:return:
"""
body_len = len(body) #integer type, 4 bytes long
header_size = 10
if body_len + header_size > max_packet_size:
raise Exception("msg len to big: {}>{}".format(body_len + header_size, max_packet_size))
body_len = struct.pack('I', body_len)
msg_id = struct.pack('H', msg_id) #two bytes
context = struct.pack('H', context) # two bytes
c = crc(body) #two bytes field
if fail_crc_factor:
if randrange(0, fail_crc_factor) == 0:
c1 = c[0]
c2 = chr(ord(c[1]) + 1) if ord(c[1]) <= 0xff else chr(ord(c[1]) - 1)
c = c1 + c2
return '>{id}{context}{body_len}{crc}<{body}'.format(id=msg_id, context=context, body_len=body_len, crc=c, body=body)
def check_tail(self, peek_buff):
init_find = peek_buff.find(MessageReceiver.TAIL_START_MARK)
peek_buff_len = len(peek_buff)
for i in xrange(peek_buff_len - MessageReceiver.TAIL_LEN + init_find):
latest_find = i + init_find
try:
tail_start_mark_pos = peek_buff[latest_find:].find(MessageReceiver.TAIL_START_MARK)
tail_end_mark_pos = tail_start_mark_pos + MessageReceiver.TAIL_LEN - 1
tail_end_mark = peek_buff[latest_find:][tail_end_mark_pos]
except IndexError:
return False
try:
if tail_end_mark == MessageReceiver.TAIL_END_MARK:
peek_buff = peek_buff[latest_find:]
tail = peek_buff[tail_start_mark_pos: tail_end_mark_pos]
_full_tail = peek_buff[tail_start_mark_pos: tail_end_mark_pos+1]
_id = struct.unpack('H', tail[1:3])[0]
_context = struct.unpack('H', tail[3:5])[0]
_msg_len = struct.unpack('H', tail[5:7])[0]
_body_crc = tail[7:9]
_tail_crc = peek_buff[tail_end_mark_pos+1: tail_end_mark_pos + MessageReceiver.TAIL_CRC_SHIFT_POS]
tail_integrity = _tail_crc == crc(_full_tail) # tail integrity check
if _id < len(RxMessage.rx_id_tuple) and _msg_len < MAX_PACKET_SIZE and _context < 0xffff \
and self.rx_buffer.available() > _msg_len and tail_integrity:
return _id, _context, _msg_len, _body_crc, tail_start_mark_pos + latest_find, tail_end_mark_pos + latest_find
except struct.error:
return False
return False
def query_command_once(cmdname, cb):
ser.write(cmdname + crc(cmdname) + "\x0d")
time.sleep(base_delay)
data = readline()
if data is None:
return None
l = len(data)
if (l > 4):
payload = data[0:len(data) - 3]
checksum = data[len(data) - 3:len(data) - 1]
pcrc = crc(payload)
if (checksum == pcrc):
# print "recv finish:"+payload
return cb(payload[1:])
else:
print "CRC fail"
return None
else:
print "Short packet"
return None
def query_command_once(cmdname, cb):
ser.write(cmdname + crc(cmdname) + "\x0d");
time.sleep(base_delay);
data = readline()
if data is None:
return None
l = len(data)
if (l > 4):
payload = data[0:len(data) - 3];
checksum = data[len(data) - 3:len(data) - 1]
pcrc = crc(payload)
if (checksum == pcrc):
# print "recv finish:"+payload
return cb(payload[1:])
else:
print "CRC fail"
return None
else:
print "Short packet"
return None
def make_auth(pid=0, as_server=False, timestamp=0):
""" Assemble authentication token. """
data = ['\x00'] * 16
if not timestamp:
timestamp = int(time())
data[:4] = pack('L', timestamp)
# 'magic number' 64 00 00 00
data[4] = 'd'
data[8:12] = pack('L', pid)
if as_server:
data[12] = 1
dc = crc(data[:14])
try:
data[14:16] = pack('H', dc)
except:
print hex(dc)
return base64(aes(data))
while len(bitstream) > 0:
# The AG10K bitstream comes in two chunks, one
# with 1394432 bits, the other with 1281280 bits
# This is to emulate that behavior
if chip.device_id == 0x01500010:
max_len = 2186240
else:
max_len = 1394432
write_register_data(index, min(max_len, len(bitstream)),
bitstream[:max_len])
bitstream = bitstream[max_len:]
index += 1
#
# Write the checksum
#
writer.write32(0x2A00FC02)
writer.write32(0x00000F8F)
writer.write32(crc(writer.getBytes()))
with open(args.output, "wb") as binfile:
if args.spi_flash:
spi_flash_header = [
0x55, 0x55, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00
]
binfile.write(bytearray(spi_flash_header))
binfile.write(writer.getBytes())
def create_checksum(self, payload):
'''
creates string version of the crc and outputs the checksum value as a string
'''
return crc(self.payload_to_binary())
def recibir(data):
recibir = pickle.loads(data)
resultado = receiver.crc(recibir)
return resultado
def calculate_checksum(self): self.checksum = crc(self.destination + self.source + self.next_protocol + self.payload)
def _checksum_ok(self, in_bytes):
calculated_crc = crc.crc(in_bytes[:-2])
received_crc = (ord(in_bytes[-1]) << 8) | ord(in_bytes[-2])
return calculated_crc == received_crc
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
''' Test cases for CRC checksums '''
from crc import crc
check = 0x313233343536373839 # b'123456789'
# Parity
assert crc(check, size=1, poly=1) == 1 # even parity
assert crc(check, size=1, poly=1, xorout=1) == 0 # odd parity
# 3-bit CRC
assert crc(0b11010011101100, size=3, poly=0b1011) == 0b100 # 3-bit wikipedia
# 8-bit CRC
assert crc(check, size=8, poly=0x07) == 0xF4 # CRC-8
assert crc(check, size=8, poly=0x9B, init=0xFF) == 0xDA # CRC-8/CDMA2000
assert crc(check, size=8, poly=0x07, init=0xFF, refin=True,
refout=True) == 0xD0 # CRC-8/ROHC
assert crc(check, size=8, poly=0x9B, refin=True,
refout=True) == 0x25 # CRC-8/WCDMA
# 16-bit CRC
assert crc(check, size=16, poly=0x8005, refin=True,
refout=True) == 0xBB3D # CRC-16/ARC
assert crc(check, size=16, poly=0x0589,
xorout=0x0001) == 0x007E # CRC-16/DECT-R
assert crc(check, size=16, poly=0x0589) == 0x007F # CRC-16/DECT-X
assert crc(check, size=16, poly=0x1021, init=0xFFFF,
xorout=0xFFFF) == 0xD64E # CRC-16/GENIBUS
# 32-bit CRC
assert crc(check,
size=32,
poly=0x04C11DB7,
def create_checksum(self, payload): ''' creates string version of the crc and outputs the checksum value as a string ''' return crc(self.payload_to_binary())
import socket
import en_decript as ed
import noise as noise
import crc as crc
import ham as ham
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('0.0.0.0', 8080))
message = 'Connected\n'
client.send(message.encode())
from_server = client.recv(4096)
a = ed.str_to_BIN('holaquetal')
b = ed.bitarray_to_BIN(from_server)
crcSays = crc.crc(b)
hamming = ham.hamming(b)
hammingB = ham.hamming_to_BIT(hamming)
print("CRC: " + crcSays)
print(ham.compare_efficency(a, hammingB))
client.send(crcSays.encode())
client.close()
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
''' CRC functions
'''
from crc import crc
# 8-bit CRC
crc8 = lambda data: crc(data, size=8, poly=0x07)
crc8cdma2000 = lambda data: crc(data, size=8, poly=0x9B, init=0xFF)
crc8rohc = lambda data: crc(
data, size=8, poly=0x07, init=0xFF, refin=True, refout=True)
crc8wcdma = lambda data: crc(data, size=8, poly=0x9B, refin=True, refout=True)
# 16-bit CRC
crc16arc = lambda data: crc(
data, size=16, poly=0x8005, refin=True, refout=True)
crc16dectr = lambda data: crc(data, size=16, poly=0x0589, xorout=0x0001)
crc16dectx = lambda data: crc(data, size=16, poly=0x0589)
crc16genibus = lambda data: crc(
data, size=16, poly=0x1021, init=0xFFFF, xorout=0xFFFF)
# 32-bit CRC
crc32 = lambda data: crc(data,
size=32,
poly=0x04C11DB7,
init=0xFFFFFFFF,
refin=True,
refout=True,
xorout=0xFFFFFFFF)
crc32q = lambda data: crc(data, size=32, poly=0x814141AB)
crc32posix = lambda data: crc(
def packet_crc_cobs(self):
mycrc = crc.crc(self.packet_as_str())
data = cobs.encode(self.packet_as_str() + chr(mycrc & 0xFF) + chr((mycrc >> 8) & 0xFF))
data = data + "\x00"
return data
def strobe(ser):
data = bytes([0x42])
checksum = crc.crc(bytes(x for i in data for x in (0, 0, 0, i)))
data += struct.pack('<H', checksum&0xffff)
ser.write(data)
print(binascii.hexlify(data))
def calculate_checksum(self):
self.checksum = crc(self.destination + self.source +
self.next_protocol + self.payload)
def set_block(ser, block, data):
data = struct.pack('<BB8H', 0x23, block, *data)
checksum = crc.crc(bytes(x for i in data for x in (0, 0, 0, i)))
data += struct.pack('<H', checksum&0xffff)
ser.write(data)
print(binascii.hexlify(data))