def bch_check(inputhex): errors = [inputhex] preamble ='' if len(inputhex)==36: strhex = inputhex[6:] preamble = inputhex[:6] elif len(inputhex)==30: strhex = inputhex preamble ='' else: return False ## Error correction attempt for when BCH portion does not match recomputed try: _pdf1 = (Fcn.hextobin(strhex))[:61] _bch1 = (Fcn.hextobin(strhex))[61:82] bitflips1, newpdf1, newbch1 = bch1.pdf1_to_bch1(_pdf1, _bch1) _pdf2 = (Fcn.hextobin(strhex))[82:108] _bch2 = (Fcn.hextobin(strhex))[108:] bitflips2, newpdf2, newbch2 = bch2.pdf2_to_bch2(_pdf2, _bch2) if bitflips1 == -1 or bitflips2 == -1: errors.append('Too many bit errors to correct') elif bitflips1 > 0 or bitflips2 > 0: _newbin = newpdf1 + newbch1 + newpdf2 + newbch2 fixhex= preamble+ Fcn.bin2hex(_newbin) errors.append(fixhex) errors.append(' {} bad pdf1 bit and {} bad pdf2 bit'.format(bitflips1, bitflips2)) errors.append('Corrected Message: {} '.format(fixhex)) except: return False return errors
def correct_bchsgb(testhex): pdf = decodefunctions.hextobin(testhex)[:204] bchsgb = (decodefunctions.hextobin(testhex))[204:] binary_data_pdf = newdata = pdf.zfill(204) correctedbch = bchsgb BCH_POLYNOMIAL = 285 BCH_BITS = 6 bitflips = 0 bch = bchlibcaronoff.BCH(BCH_BITS, m=8, prim_poly=BCH_POLYNOMIAL) max_data_len = bch.n // 8 - (bch.ecc_bits + 7) // 8 + 1 data = bytearray(bch1correct.bitstring_to_bytes(binary_data_pdf)) rebuildpdf = '' for e in range(len(data)): segment = decodefunctions.dec2bin(data[e]).zfill(8) rebuildpdf = rebuildpdf + segment rebuildpdf = rebuildpdf.zfill(204) ecc = bch.encode(data) bchstring = '' for e in ecc: binchar = decodefunctions.dec2bin(e).zfill(8) bchstring = bchstring + binchar ecc_provided = bytearray(bch1correct.bitstring_to_bytes(bchsgb)) packet = data + ecc_provided if ecc != ecc_provided: data, ecc = packet[:-bch.ecc_bytes], packet[-bch.ecc_bytes:] bch.data_len = max_data_len nerr = bch.decode(data, ecc) bitflips = nerr bch.correct(data, ecc) newdata = decodefunctions.dec2bin(data[0]) for e in data[1:]: binchar = decodefunctions.dec2bin(e).zfill(8) newdata = newdata + binchar newdata = newdata.zfill(204) correctedbch = '' for e in ecc: binchar = decodefunctions.dec2bin(e).zfill(8) correctedbch = correctedbch + binchar newhex = decodefunctions.bin2hex(newdata + correctedbch) else: bitflips = 0 newdata = pdf correctedbch = bchsgb newhex = decodefunctions.bin2hex(pdf + bchsgb) return (bitflips, newdata, correctedbch, newhex)
def make_full(hexinput): pdf1 = decodefunctions.hextobin(hexinput) b = pdf1[:204] + '0' * 48 print(b, len(b)) ecc = calcBCH(b, 0, 202, 250) newhex = decodefunctions.bin2hex(pdf1[:204] + ecc) print(newhex) print(ecc, decodefunctions.bin2hex(ecc)) BCH_POLYNOMIAL = 285 # 285 BCH_BITS = 6 bitflips = 0 bch = bchlib.BCH(BCH_POLYNOMIAL, BCH_BITS) max_data_len = bch.n // 8 - (bch.ecc_bits + 7) // 8 data = bytearray(bch1correct.bitstring_to_bytes(pdf1[:204])) necc = bch.encode(data) bchstring = '' for e in necc: binchar = decodefunctions.dec2bin(e).zfill(8) bchstring = bchstring + binchar print(bchstring, decodefunctions.bin2hex(bchstring)) newhex = decodefunctions.bin2hex(pdf1[:204] + bchstring) return newhex
def bch1_binarycalc(inputhex): try: bin = Fcn.hextobin(inputhex) except TypeError as err: return [inputhex + ' Is not a valid hex'] result = '' if len(inputhex) == 36: strhex = inputhex[6:] bin = bin[24:] result = Fcn.calcbch(bin, "1001101101100111100011", 0, 61, 82) elif len(inputhex) == 30: strhex = inputhex result = Fcn.calcbch(bin, "1001101101100111100011", 0, 61, 82) elif len(inputhex) == 63: # SGB recalc bch1 strhex = inputhex result = Fcn2.calcBCH(bin[2:], 0, 202, 250) else: result = 'Invalid Input Hex length of ' + str( len(inputhex)) + '.' + ' Valid length of FGB 30/36 or 63 for SGB' return result
def bch2_binarycalc(inputhex): try: bin = Fcn.hextobin(inputhex) except TypeError as err: return [inputhex + ' Is not a valid hex'] result = '' if len(inputhex) == 36: strhex = inputhex[6:] bin = bin[24:] result = Fcn.calcbch(bin, '1010100111001', 82, 108, 120) elif len(inputhex) == 30: strhex = inputhex result = Fcn.calcbch(bin, '1010100111001', 82, 108, 120) elif len(inputhex) == 63: return "" else: result = 'Invalid Input Hex length of ' + str( len(inputhex)) + '.' + ' Valid lengths of FGB message are 30 or 36' return result
def random_error(hexvalid, pdf1err, pdf2err, sgberr): #pdf1/bc1 errors correctible 3 #pdf2/bc2 errors correctible 2 scramble = list(Fcn.hextobin(hexvalid)) #print(scramble) b = Fcn.hextobin(hexvalid) if pdf1err or pdf2err: for ipos in random.sample(range(0, 82), pdf1err): scramble[ipos] = str(int(not int(scramble[ipos]))) for j in random.sample(range(82, 120), pdf2err): scramble[j] = str(int(not int(scramble[j]))) elif sgberr: for i in range(int(sgberr)): epos = random.randint(0, 251) scramble[epos] = str(int(not int(scramble[epos]))) return Fcn.bin2hex(''.join(scramble))
def test_hex(testhex): pdf = decodefunctions.hextobin(testhex)[:204] print(pdf) print(len(pdf)) bch = (decodefunctions.hextobin(testhex))[204:] print(bch, len(bch)) bitflips, newpdf, newbch = pdf_to_bchsgb(pdf, bch) print('errors result: ', bitflips) if bitflips == -1: print('fail') elif bitflips == 0: print('match') elif bitflips > 0: print(20 * '-' + 'ORIGINAL MESSAGE' + 25 * '-') print(testhex) print(20 * '-' + 'CORRECTED MESSAGE' + 25 * '-') print(decodefunctions.bin2hex(newpdf + newbch)) print(newpdf + newbch)
def bch_recalc(inputhex): results = [inputhex] preamble = '' if len(inputhex) == 36: strhex = inputhex[6:] preamble = inputhex[:6] elif len(inputhex) == 30: strhex = inputhex preamble = '' else: type = 'Hex length of ' + str( len(inputhex) ) + '.' + ' Length of First Generation Beacon Hex Code to test BCH must be 30 or 36' return [type] try: bin = Fcn.hextobin(strhex) _pdf1 = (bin)[:61] _bch1 = (bin)[61:82] _pdf2 = (bin)[82:108] _bch2 = (bin)[108:] bch1calc = Fcn.calcbch(bin, "1001101101100111100011", 0, 61, 82) bch2calc = Fcn.calcbch(bin, '1010100111001', 82, 108, 120) if _pdf1 + bch1calc + _pdf2 + bch2calc == bin: results.append( 'bch1 and bch2 recomputed from provided pdf1 and pdf2 match') else: if bch1calc != _bch1: results.append( 'bch1 recomputed from provided pdf1 in input message {}'. format(bch1calc)) if bch2calc != _bch2: results.append( 'bch2 recomputed from provided pdf2 in input message {}'. format(bch2calc)) results.append(preamble + Fcn.bin2hex(_pdf1 + bch1calc + _pdf2 + bch2calc)) return results except TypeError as err: return [inputhex + ' Is not a valid hex']
bch1= input("bch1: ") if not pdf1: pdf1='1101001111000100111010110010100000010100000010101010011010000' bch1='001000100000000101001' bitflips,newpdf,newbch = pdf1_to_bch1(pdf1,bch1) print(pdf1) print(newpdf,len(newpdf)) print print(bch1) print(newbch,len(newbch)) print(bitflips) if bitflips==-1: print('fail') pdf1=(decodefunctions.hextobin('D3C4EB28140AA681100A444154C224'))[:61] bch1=(decodefunctions.hextobin('D3C4EB28140AA681100A444154C224'))[61:82] #print('93CB0242508F3BC928BCB407180EC6',pdf1,len(pdf1)) #print('bch1',bch1,len(bch1)) pdf1= (decodefunctions.hextobin('9D6940000045DF533687000452A622'))[:61] bch1 = (decodefunctions.hextobin('9D6940000045DF533687000452A622'))[61:82] bch1corrected = decodefunctions.calcbch(pdf1,"1001101101100111100011", 0, 61, 82) pdf2bch2=(decodefunctions.hextobin('9D6940000045DF533687000452A622'))[82:] print(pdf1+bch1,len(pdf1+bch1)) print(bch1corrected) print(pdf1 + bch1 + pdf2bch2, len(pdf1 + bch1+pdf2bch2)) print(decodefunctions.bin2hex((pdf1 + bch1corrected+pdf2bch2)))
def processHex(self, strhex): self.bch1 = self.bch2 = self.tac = 'na' self.courseloc = ('na', 'na') self.location = ('na', 'na') self.fixedbits = '' self.hex = str(strhex) self.count = 1 #print strhex self._loc = False self.tablebin = [] if Fcn.hextobin(strhex): if len(strhex) == 15: # 15 Hex does not use bit 25 so an extra 0 needs to be padded self.type = '15 Hex ID' pad = '0' * 25 elif len(strhex) == 22: self.type = 'Short Message' pad = '0' * 24 elif len(strhex) == 30: self.type = 'Long Msg no Framesynch' pad = '0' * 24 elif len(strhex) == 36: pad = '' self.type = 'Long Msg with Framesynch' else: self.type = 'Hex length of ' + str( len(strhex) ) + '.' + '\nLength of First Generation Beacon Hex Code must be 15, 22 or 30' raise HexError('LengthError', self.type) self.hexcode = str(strhex) else: self.type = 'Not a valid Hex ID' raise HexError('FormatError', self.type) self.bin = '_' + pad + Fcn.hextobin( strhex) + (144 - len(pad + Fcn.hextobin(strhex))) * '0' if self.bin[17:25] == '11010000': self.testmsg = '1' else: self.testmsg = '0' self.bch = Bch(self.bin, self.type) self.id = () if self.type != '15 Hex ID': formatflag = (self.bin[25], definitions.messagetype[self.bin[25]]) else: formatflag = ('n/a', 'bit 25 not relevant in 15 Hex') protocolflag = self.bin[26] self.formatflag = formatflag self.countrydetail = Country(self.bin[27:37]) #self.country() # protocol == '0' :Standard Location Protocol. # type of location protocol is found at bits 37-40 self._pflag = ['Location', 'User'][int(self.bin[26])] self.tablebin.append( ['25', self.bin[25], 'Message format', self.formatflag[1]]) self.tablebin.append( ['26', self.bin[26], 'User or Location Protocol', self._pflag]) self.tablebin.append( ['27-36', self.bin[27:37], 'Country', self.countrydetail.cname]) if protocolflag == '0': self.locationProtocol() # protocol == '1' 'User Protocol' # type of user protocol located at bits 37-39 elif protocolflag == '1': self.userProtocol()
for e in ecc: binchar = decodefunctions.dec2bin(e).zfill(8) # #print(e, binchar) correctedbch2 = correctedbch2 + binchar if (len(correctedbch2)) > 12: correctedbch2 = correctedbch2[:12] return (bitflips, newdata.zfill(26), correctedbch2) if __name__ == "__main__": pdf2 = input("pdf2: ") bch2 = input("bch2: ") if not pdf2: pdf2 = '00010001000001010101001100' bch2 = '001000100100' bitflips, newpdf, newbch = pdf2_to_bch2(pdf2, bch2) print(pdf2) print(newpdf, len(newpdf)) print(bch2) print(newbch) print(bitflips) if bitflips == -1: print('fail') pdf2 = (decodefunctions.hextobin('D3C4EB28140AA681100A444154C224'))[82:108] bch2 = (decodefunctions.hextobin('D3C4EB28140AA681100A444154C224'))[108:] print('D3C4EB28140AA681100A444154C224', pdf2, len(pdf2)) print('bch2', bch2, len(bch2))
mainmsg='0001110000111101111010001001111111000011111111100111100011111001110010001111101111000100010010000011101101111001001011110000101110110010001000100011001001110110100101000001010001110100010001011110110110' bchsgb='011001011000001000000101110011100111001101100010' print(mainmsg,bchsgb) calculatedBCH = Sgb.calcBCH(mainmsg, 0, 202, 250) print(calculatedBCH, len(calculatedBCH),bchsgb==calculatedBCH) print(Fcn.bin2hex('00'+mainmsg+calculatedBCH)) print(len(mainmsg)) h='070F7A27F0FF9E3E723EF1120EDE4BC2EC888C9DA5051D117B6658205CE7362' bitflips,newmsg,newbch = msgbits_to_bch(mainmsg,bchsgb) #print(mainmsg) #print(newmsg,len(newmsg)) #print(bchsgb) #print(newbch,len(newbch)) #print(bitflips) #if bitflips==-1: # print('fail') testhex='00039A3D32618658622811F000000000001FFFF004030680258AB06AAA95EB9' m=(Fcn.hextobin(testhex))[2:204] b=(Fcn.hextobin(testhex))[204:] #print(testhex) #print(m,len(m)) #print('bch',b,len(b))
except: return False return errors if __name__ == "__main__": strhex = input("Hex message: ") errors = [] #errors = bch_recalc(strhex) if errors: print(errors) _pdf1 = (Fcn.hextobin(strhex))[:61] print(len(_pdf1)) _bch1 = (Fcn.hextobin(strhex))[61:82] bitflips1, newpdf1, newbch1 = bch1.pdf1_to_bch1(_pdf1, _bch1) _pdf2 = (Fcn.hextobin(strhex))[82:108] _bch2 = (Fcn.hextobin(strhex))[108:] bitflips2, newpdf2, newbch2 = bch2.pdf2_to_bch2(_pdf2, _bch2) if bitflips1 == -1 or bitflips2 == -1: print('Too many bit errors to correct') elif bitflips1 > 0 or bitflips2 > 0: _newbin = newpdf1 + newbch1 + newpdf2 + newbch2 print(' {} bad pdf1 bit and {} bad pdf2 bit'.format( bitflips1, bitflips2)) print('Corrected Message: {} '.format(Fcn.bin2hex(_newbin))) print(_newbin, len(_newbin), len(newpdf1), len(newbch1), len(newpdf2), len(newbch2))
if __name__ == "__main__": pdf1 = input("pdf1: ") bch1 = input("bch1: ") if not pdf1: pdf1 = '1001001111001011000000100100001001010000100011110011101111001' bch1 = '001001010001011110010' bitflips, newpdf, newbch = pdf1_to_bch(pdf1, bch1) print(newpdf) print(newbch) print(bitflips) if bitflips == -1: print('fail') pdf1 = (decodefunctions.hextobin('93CB0242508F3BC928BCB407180EC6'))[:61] bch1 = (decodefunctions.hextobin('93CB0242508F3BC928BCB407180EC6'))[61:82] #print('93CB0242508F3BC928BCB407180EC6',pdf1,len(pdf1)) #print('bch1',bch1,len(bch1)) # if not valid: # #errors detected so correct in place # print(bch1) # ecc_provided_t = bytearray(bitstring_to_bytes(bch1)) # bchstr='' # for e in ecc_provided_t: # binchar = decodefunctions.dec2bin(e).zfill(8) # bchstr=bchstr+binchar # print(binchar) # print(bchstr,len(bchstr),decodefunctions.dec2bin(decodefunctions.bin2dec(bchstr))) # bch1_recalc=decodefunctions.dec2bin(decodefunctions.bin2dec(bchstr))