def test_MSB_LSB(self):
data = NumberMask(random.randint(1, 0xFF), 8)
crcSize = 8
crcMax = 2**crcSize - 1
inputPoly = NumberMask(random.randint(1, crcMax), crcSize)
regInit = random.randint(0, crcMax)
xorOut = random.randint(0, crcMax)
crcProc = DivisionCRC()
crcProc.setRegisterInitValue(regInit)
crcProc.setXorOutValue(xorOut)
crc = crcProc.calculateMSB(data, inputPoly)
revData = data.reversed()
revPoly = inputPoly.reversed()
revRegInit = reverse_number(regInit, crcSize)
revXorOut = reverse_number(xorOut, crcSize)
revCrcProc = DivisionCRC()
revCrcProc.setReversed()
revCrcProc.setRegisterInitValue(revRegInit)
revCrcProc.setXorOutValue(revXorOut)
crc2 = revCrcProc.calculateLSB(revData, revPoly)
revCrc = reverse_number(crc2, crcSize)
# print "values: data:{} poly:{:X} init:{:X} xorOut:{:08b} crc:{:08b} revcrc:{:08b}".format( data, inputPoly, regInit, xorOut, crc, revCrc )
self.assertEqual(crc, revCrc)
def test_hw_crc8_calculate_1_reverse(self):
data = 0x12
dataSize = 8
poly = 0xBF
poly = reverse_number(poly, 8)
bytes_list = convert_to_lsb_list(data, dataSize / 8)
calc_crc = hw_crc8_calculate(bytes_list, poly, 0x00, 0x00)
calc_crc = reverse_number(calc_crc, 8)
self.assertEqual(calc_crc, 0x3F) ## 63
def test_hw_crc8_calculate_3_reverse(self):
data = 0x000300
dataSize = 24
poly = 0x1BF
poly = reverse_number(poly, 8)
bytes_list = convert_to_lsb_list(data, dataSize / 8)
calc_crc = hw_crc8_calculate(bytes_list, poly, 0x00, 0x00)
calc_crc = reverse_number(calc_crc, 8)
self.assertEqual(calc_crc, 0x50) ## 80
def test_reverse_number(self):
val = reverse_number(0b11000001)
self.assertEqual(val, 0b10000011)
val = reverse_number(0x1021)
self.assertEqual(val, 0x1081) ## 0x8408
val = reverse_number(0x11021)
self.assertEqual(val, 0x10811)
val = reverse_number(0x8005)
self.assertEqual(val, 0xA001)
def calculateLSB(self, dataMask, polyMask):
# return self.calculateLSBClassic(dataMask, polyMask)
if dataMask.dataSize % 8 != 0:
## fast crc only supports full bytes
return self.calculateLSBClassic(dataMask, polyMask)
bytesList = convert_to_lsb_list(dataMask.dataNum,
dataMask.dataSize / 8)
poly = reverse_number(polyMask.dataNum, polyMask.dataSize)
initReg = reverse_number(self.registerInit, polyMask.dataSize)
xor_val = reverse_number(self.xorOut, polyMask.dataSize)
calc_crc = hw_crc8_calculate(bytesList, poly, initReg, xor_val)
return reverse_number(calc_crc, polyMask.dataSize)
def calculateLSBUsingMSB(self, dataMask, polyMask):
revData = dataMask.reversed()
revPoly = polyMask.reversed()
oldInit = self.registerInit
oldXor = self.xorOut
self.registerInit = reverse_number(self.registerInit,
polyMask.dataSize)
self.xorOut = reverse_number(self.xorOut, polyMask.dataSize)
calc_crc = self.calculateMSBClassic(revData, revPoly)
self.registerInit = oldInit
self.xorOut = oldXor
return reverse_number(calc_crc, polyMask.dataSize)
def test_crcmod_c16d64_random(self):
data = NumberMask(random.randint(1, 0xFFFFFFFFFFFFFFFF), 64)
crcSize = 16
crcMax = 2**crcSize - 1
inputPoly = NumberMask((0x1 << crcSize) | random.randint(1, crcMax),
crcSize)
# regInit = random.randint(0, crcMax)
# xorOut = random.randint(0, crcMax)
regInit = 0x0
xorOut = 0x0
reverse = bool(random.randint(0, 1))
crc_func = crcmod.mkCrcFun(inputPoly.masterData(),
rev=reverse,
initCrc=regInit,
xorOut=xorOut)
crcLib = crc_func(data.toASCII())
# print "crc: {:X} {:X}".format( crc, crc2 )
crcProc = HwCRC()
crcProc.setReversed(reverse)
crcProc.setXorOutValue(xorOut)
if reverse:
data.reorderBytes()
inputPoly.reverse()
crcInit = reverse_number(regInit ^ xorOut, crcSize)
crcProc.setRegisterInitValue(crcInit)
else:
crcInit = regInit ^ xorOut
crcProc.setRegisterInitValue(crcInit)
crc = crcProc.calculate3(data, inputPoly)
# print "values: {} poly:{:X} init:{:X} xorOut:{:08b} rev:{} crc:{:08b} crcmod:{:08b} crcxor:{:08b}".format( data, inputPoly, regInit, xorOut, reverse, crc, crcLib, crc^crcLib )
self.assertEqual(crc, crcLib)
def setInitCRC(self, value, crcSize):
self.registerInit = value ^ self.xorOut
if self._reversed is True:
self.registerInit = reverse_number(self.registerInit, crcSize)
def reflect_bits_list(number_list):
for i in xrange(0, len(number_list)):
number_list[i] = reverse_number(number_list[i], 8)
def test_reverse_number_size(self):
val = reverse_number(0x0FA, 12)
self.assertEqual(val, 0x5F0)
val = reverse_number(0x4441, 16)
self.assertEqual(val, 0x8222)
