def bchmatch(self):
if len(self.bits)>=249:
if Func.errors(Func.calcBCH(self.bits[1:], 0, 202, 250), self.bits[203:])>0:
return 'COMPUTED BCH DOES NOT MATCH ENCODED BCH!!'
else:
return 'SGB BCH matches encoded'
return ''
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 sgbcompute(f, r):
for n in range(r):
pdf = randombinary(202).zfill(202)
bchcalc = sgb.calcBCH(pdf + '0' * 48, 0, 202, 250)
finalbin = (pdf + bchcalc).zfill(252)
hexvalid = Fcn.bin2hex(finalbin)
r1 = random.randint(0, 8)
r1 = 6
hexbad = random_error(hexvalid, 0, 0, r1)
f.writelines(['{},{},{}'.format(hexvalid, str(r1), hexbad), '\n'])
def processHex(self, strhex):
##All second generation beacon messages must be EXACTLY 250 bits
##in length for the program to function properly.
self.bits = Func.hex2bin(strhex)
self.bchstring = ''
self.tablebin = []
self.rotatingbin = []
self.longitude = self.latitude = 'na'
self.location = (0, 0)
self.courseloc = ('na', 'na')
self.errors = []
self.fixedbits = ''
self.testprotocol = ''
if len(self.bits) == 252 or len(self.bits) == 204:
self.type = "Complete message"
pbit = self.bits[0:2]
if pbit == '00':
padding = 'OK'
else:
padding = 'ERROR! left padding should be 00'
self.errors.append(padding)
##Add an additional bit to ensure that bits in array line up with bits in documentation and only include important bits 1-202
self.bits = "0" + self.bits[2:]
##Add the 23 Hex ID to our table
self.beaconHexID = self.uinSgb()
self.tablebin.append(
['', '', 'Beacon 23 Hex ID:', self.beaconHexID])
self.tablebin.append(['left padding', pbit, '', padding])
##BIT 1-20 Type Approval Certificate #
self.tac = Func.bin2dec(self.bits[1:21])
if self.tac < 10000:
warn = 'WARNING!: SGB requires TAC No >=10,000'
else:
warn = ''
self.tablebin.append([
'1-20', self.bits[1:21],
'Type Approval Cert No: ' + str(self.tac), warn
])
##BIT 21-30 Serial Number
self.serialNum = Func.bin2dec(self.bits[21:31])
self.tablebin.append([
'21-30', self.bits[21:31], 'Serial Number:',
str(self.serialNum)
])
##BIT 31-40 Country code
self.countryCode = Func.bin2dec(self.bits[31:41])
self.countryName = Func.countryname(self.countryCode)
self.tablebin.append([
'31-40', self.bits[31:41], 'Country code:',
str(self.countryCode) + ' ' + str(self.countryName)
])
##BIT 41 Status of homing device
self.status = Func.homing(self.bits[41])
self.tablebin.append(
['41', self.bits[41], 'Status of homing device:', self.status])
##BIT 42 Self-test function
self.selfTestStatus = Func.selfTest(self.bits[42])
self.tablebin.append(
['42', self.bits[42], 'Self-test flag:', self.selfTestStatus])
##BIT 43 Test protocol
self.testprotocol = Func.testProtocol(self.bits[43])
self.tablebin.append([
'43', self.bits[43], 'Test protocol flag:', self.testprotocol
])
##BIT 44-90 Encoded GNSS location
self.latitude = Func.getlatitude(self.bits[44:67])
self.tablebin.append(
['44-66', self.bits[44:67], 'Latitude:', self.latitude[0]])
self.longitude = Func.getlongitude(self.bits[67:91])
self.tablebin.append(
['67-90', self.bits[67:91], 'Longitude:', self.longitude[0]])
self.location = (self.latitude[1], self.longitude[1])
################################
# #
# BIT 91-137 VESSEL ID FIELD #
# #
################################
self.vesselIDfill(0, self.bits[91:138])
## BIT 138-139 Beacon Type
self.tablebin.append([
'138-139', self.bits[138:140], 'Beacon Type:',
Func.getBeaconType(self.bits[138:140])
])
## BIT 140 RLS capability
self.tablebin.append([
'140', self.bits[140], 'RLS capability:',
Func.rls(self.bits[140])
])
##BIT 140-154 Spare bits
if Func.checkones(self.bits[141:155]) and not Func.checkones(
self.bits[155:159]):
self.tablebin.append([
'141-154', self.bits[141:155], 'Spare bits',
'OK - all bits 1 and rotating field not a cancellation message'
])
elif Func.checkones(self.bits[141:155]) and Func.checkones(
self.bits[155:159]):
e = 'ERROR! - all bits 1 and rotatating field is a cancellation message (for a cancellation message these bits should be set to 0)'
self.errors.append(e)
self.tablebin.append(
['141-154', self.bits[141:155], 'Spare bits', e])
elif Func.checkzeros(self.bits[141:155]) and Func.checkones(
self.bits[155:159]):
self.tablebin.append([
'141-154', self.bits[141:155], 'Spare bits',
'OK - all bits 0 and rotating field is cancellation message (unless this is a cancellation message, these bits should be set to 1'
])
elif Func.checkzeros(self.bits[141:155]) and not Func.checkones(
self.bits[155:159]):
e = 'ERROR!- all bits 0 and rotating field is not cancellation message'
self.errors.append(e)
self.tablebin.append(
['141-154', self.bits[141:155], 'Spare bits', e])
else:
e = 'ERROR: Bits 141-154 should be set to all 1 or all 0 in the case that the rotating field is a cancellation message'
self.errors.append(e)
self.tablebin.append([
'141-154', self.bits[141:155],
'Cancellation message status:', e
])
#######################################
# #
# BIT 155-202 48 BIT ROTATING FIELD #
# #
#######################################
self.rotatingID = Func.bin2dec(self.bits[155:159])
######################################################
# Rotating Field 0: C/S G.008 Objective Requirements #
######################################################
if self.rotatingID == 0:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:',
'(#0) C/S G.008 Objective Requirements'
])
self.rotatingbin = rotating.rotating0(self.bits[155:203])
########################################
# Rotating Field 1: Inflight Emergency #
########################################
elif self.rotatingID == 1:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#1) Inflight Emergency'
])
self.rotatingbin = rotating.rotating1(self.bits[155:203])
#########################
# Rotating Field 2: RLS #
#########################
elif self.rotatingID == 2:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#2) RLS'
])
self.rotatingbin = rotating.rotating2(self.bits[155:203])
##################################
# Rotating Field 3: National Use #
##################################
elif self.rotatingID == 3:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#3) National Use'
])
self.rotatingbin = rotating.rotating3(self.bits[155:203])
###########################################
# Rotating Field 15: Cancellation Message #
###########################################
elif self.rotatingID == 15:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#15) Cancellation Message'
])
self.rotatingbin = rotating.rotating15(self.bits[155:203])
##################################
# All other rotating fields spare #
##################################
else:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', 'Spare'
])
##Add rotating field data to our list
self.tablebin.extend(self.rotatingbin)
####################################
# 48-BIT BCH ERROR CORRECTING CODE #
####################################
if len(self.bits) == 251:
self.tablebin.append(
['203-250', self.bits[203:], 'Encoded BCH', 'Encoded BCH'])
##Calculate the BCH
self.calculatedBCH = Func.calcBCH(self.bits[1:], 0, 202, 250)
self.bchstring = writebch.calcBCH(self.bits[1:], 0, 202,
250)[1]
self.tablebin.append(
['Calculated', self.calculatedBCH, 'Computed', ''])
##Compare to the BCH in the beacon message
bcherr = self.BCHerrors = Func.errors(self.calculatedBCH,
self.bits[203:])
if bcherr > 0:
bcherror = 'COMPUTED BCH DOES NOT MATCH ENCODED BCH!!'
self.errors.append(bcherror)
self.tablebin.append(['', '', '', bcherror])
elif len(self.bits) == 92:
self.type = 'uin'
##Add an additional bit to ensure that bits in array line up with bits in documentation
self.bits = "0" + self.bits
self.latitude = self.longitude = 'No data available'
self.tablebin.append(['Unique ID', 'Second Generation', '', ''])
self.tablebin.append([
'1', self.bits[1], 'should be 1', ['ERROR',
'OK'][int(self.bits[1])]
])
##BIT 2-11 Country code
self.countryCode = Func.bin2dec(self.bits[2:12])
self.countryName = Func.countryname(self.countryCode)
self.tablebin.append([
'2-11', self.bits[2:12], 'Country code:',
str(self.countryCode) + ' ' + str(self.countryName)
])
##BIT 12-14 Should be 101
if self.bits[12:15] == '101':
status_check = 'OK'
else:
status_check = 'ERROR'
self.tablebin.append(
['12-14', self.bits[12:15], 'Should be 101', status_check])
##BIT 15-34 Type Approval Certificate #
self.tac = Func.bin2dec(self.bits[15:35])
if self.tac < 10000:
warn = 'WARNING! SGB specifications requires TAC No >=10,000'
else:
warn = ''
self.tablebin.append([
'15-34', self.bits[15:35],
'Type Approval Cert No: ' + str(self.tac), warn
])
##BIT 35-44 Beacon Serial Number
self.serialNum = Func.bin2dec(self.bits[35:45])
self.tablebin.append([
'35-44', self.bits[35:45], 'Serial Number',
str(self.serialNum)
])
if self.bits[61:] == '0' * 32:
print('truncated sgb 15 hex id')
self.tablebin.append([
'45-47', self.bits[45:48], 'Vessel ID Type',
Func.getVesselid(self.bits[45:48])
])
self.tablebin.append([
'48-60', self.bits[48:], 'Remaining bits',
'Truncated SGB Hex ID does not allow vessel ID information to be decoded'
])
else:
##BIT 45-91 Aircraft / Vessel ID
self.vesselIDfill(46, self.bits[45:92])
##BIT 92 Fixed value 1
if self.bits[92] == '1':
status_check = 'OK'
else:
status_check = 'ERROR'
self.tablebin.append(
['92', self.bits[92], 'Fixed 1', status_check])
else:
self.type = (
'Hex string length of ' + str(len(strhex)) + '.' +
'\nBit string length of ' + str(len(self.bits)) + '.' +
'\nLength of First Gen Beacon Hex String must be 15, 22 or 30'
+
'\nLength of Second Gen Beacon Bit String must be 204 or 252 bits'
)
raise Gen2Error('LengthError', self.type)
def processHex(self, strhex):
##All second generation beacon messages must be EXACTLY 250 bits
##in length for the program to function properly.
self.bits = Func.hex2bin(strhex)
self.inputhex = strhex
self.bchstring = ''
self.tablebin = []
self.rotatingbin = []
self.longitude = self.latitude = 'na'
self.location = (0, 0)
self.courseloc = ('na', 'na')
self.errors = []
self.warnings = []
self.fixedbits = ''
self.testprotocol = ''
self._id = 'na'
self.SerialNum = 0
self.tac = 0
if len(self.bits) == 252 or len(self.bits) == 204:
self.type = "Complete SGB message"
pbit = self.bits[0:2]
if pbit == '00':
padding = 'Normal mode transmission (i.e., operational mode)'
elif pbit == '10':
padding = 'Self-test mode transmission'
else:
padding = 'ERROR! first two bits not 00 nor 10'
self.errors.append(padding)
self.tablebin.append(['Left pad', pbit, '', padding])
##Add an additional bit to ensure that bits in array line up with bits in documentation and only include important bits 1-202
self.bits = "0" + self.bits[2:]
##Add the 23 Hex ID to our table
self.beaconHexID = self.uinSgb()
#self.tablebin.append(['','','Beacon 23 Hex ID:',self.beaconHexID])
#self.tablebin.append(['left padding',pbit,'',padding])
##T018 Issue 1 - Rev 4: Bit 1-16 Type Approval Certificate # (previously BIT 1-20 Type Approval Certificate #)
self.tac = Func.bin2dec(self.bits[1:17])
if self.tac < 10000:
warn = '# {} Warning: SGB specifications stipulate TAC No should be greater than 10,000'.format(
self.tac)
self.warnings.append('TAC ' + warn)
elif self.tac > 65520:
warn = '# {} - System beacon'.format(self.tac)
else:
warn = '# {}'.format(self.tac)
self.tablebin.append(
['1-16', self.bits[1:17], 'Type Approval Cert No: ', warn])
##T018 Issue 1 - Rev 4: Bit 17-30 Serial Number (previously bit 21-30 Serial Number)
self.SerialNum = Func.bin2dec(self.bits[17:31])
self.tablebin.append([
'17-30', self.bits[17:31], 'Beacon serial number:',
str(self.SerialNum)
])
##BIT 31-40 Country code
self.countryCode = Func.bin2dec(self.bits[31:41])
self.countryName = Func.countryname(self.countryCode)
self.tablebin.append([
'31-40', self.bits[31:41], 'Country code:',
str(self.countryCode) + ' ' + str(self.countryName),
definitions.moreinfo['country_code']
])
##BIT 41 Status of homing device
self.status = Func.homing(self.bits[41])
self.tablebin.append(
['41', self.bits[41], 'Status of homing device:', self.status])
####T018 Issue 1 - Rev 4: Bit 42: RLS Function ( previously Bit 42 Self-test function )
self.tablebin.append([
'42', self.bits[42], 'RLS function capability:',
Func.rls(self.bits[42])
])
##BIT 43 Test protocol
self.testprotocol = Func.testProtocol(self.bits[43])
self.tablebin.append([
'43', self.bits[43], 'Test protocol flag:', self.testprotocol
])
##BIT 44-90 Encoded GNSS location
self.latitude = Func.getlatitude(self.bits[44:67])
if 'Invalid' in self.latitude[0]:
self.errors.append(self.latitude[0])
self.tablebin.append(
['44-66', self.bits[44:67], 'Latitude:', self.latitude[0]])
self.longitude = Func.getlongitude(self.bits[67:91])
if 'Invalid' in self.longitude[0]:
self.errors.append(self.longitude[0])
self.tablebin.append(
['67-90', self.bits[67:91], 'Longitude:', self.longitude[0]])
self.location = (self.latitude[1], self.longitude[1])
################################
# #
# BIT 91-137 VESSEL ID FIELD #
# #
################################
self.vesselIDfill(0, self.bits[91:138])
## T018 Iss.1 Rev.4 Bit 138-140 Beacon Type (previous (Bit 138-139 Beacon Type)
self.tablebin.append([
'138-140', self.bits[138:141], 'Beacon Type:',
Func.getBeaconType(self.bits[138:141])
])
## T018 Iss.1 Rev.4 removed
'''
self.tablebin.append(['140',
self.bits[140],
'RLS capability:',
Func.rls(self.bits[140])])
'''
##BIT 141-154 Spare bits
if Func.checkones(self.bits[141:155]) and not Func.checkones(
self.bits[155:159]):
self.tablebin.append([
'141-154', self.bits[141:155], 'Spare bits',
'OK - all bits 1 and rotating field not a cancellation message'
])
elif Func.checkones(self.bits[141:155]) and Func.checkones(
self.bits[155:159]):
e = 'ERROR! - all bits 1 and rotatating field is a cancellation message (for a cancellation message these bits should be set to 0)'
self.errors.append(e)
self.tablebin.append(
['141-154', self.bits[141:155], 'Spare bits', e])
elif Func.checkzeros(self.bits[141:155]) and Func.checkones(
self.bits[155:159]):
self.tablebin.append([
'141-154', self.bits[141:155], 'Spare bits',
'OK - all bits 0 and rotating field is cancellation message (unless this is a cancellation message, these bits should be set to 1'
])
elif Func.checkzeros(self.bits[141:155]) and not Func.checkones(
self.bits[155:159]):
e = 'ERROR!- all bits 0 and rotating field is not cancellation message'
self.errors.append(e)
self.tablebin.append(
['141-154', self.bits[141:155], 'Spare bits', e])
else:
e = 'ERROR: Bits 141-154 should be set to all 1 or all 0 in the case that the rotating field is a cancellation message'
self.errors.append(e)
self.tablebin.append([
'141-154', self.bits[141:155],
'Cancellation message status:', e
])
#######################################
# #
# BIT 155-202 48 BIT ROTATING FIELD #
# #
#######################################
self.rotatingID = Func.bin2dec(self.bits[155:159])
######################################################
# Rotating Field 0: C/S G.008 Objective Requirements #
######################################################
if self.rotatingID == 0:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:',
'(#0) C/S G.008 Objective Requirements'
])
self.rotatingbin = rotating.rotating0(self.bits[155:203])
########################################
# Rotating Field 1: Inflight Emergency #
########################################
elif self.rotatingID == 1:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#1) ELT(DT) In-flight Emergency'
])
self.rotatingbin = rotating.rotating1(self.bits[155:203])
#########################
# Rotating Field 2: RLS #
#########################
elif self.rotatingID == 2:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#2) RLS'
])
self.rotatingbin = rotating.rotating2(self.bits[155:203])
##################################
# Rotating Field 3: National Use #
##################################
elif self.rotatingID == 3:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#3) National Use'
])
self.rotatingbin = rotating.rotating3(self.bits[155:203])
###########################################
# Rotating Field 15: Cancellation Message #
###########################################
elif self.rotatingID == 15:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#15) Cancellation Message'
])
self.rotatingbin = rotating.rotating15(self.bits[155:203])
##################################
# All other rotating fields spare #
##################################
else:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', 'Spare'
])
##Add rotating field data to our list
self.tablebin.extend(self.rotatingbin)
####################################
# 48-BIT BCH ERROR CORRECTING CODE #
####################################
if len(self.bits) == 251:
# 251 length means 250 plus the stub 0, minus the extra 2 digits of front padding in self.bits
self.tablebin.append(
['203-250', self.bits[203:], 'Encoded BCH', 'Encoded BCH'])
##Calculate the BCH
self.calculatedBCH = Func.calcBCH(self.bits[1:], 0, 202, 250)
self.bchstring = writebch.calcBCH(self.bits[1:], 0, 202,
250)[1]
self.tablebin.append(
['Calculated', self.calculatedBCH, 'Computed', ''])
#self.tablebin.append(['','','','self.calculatedBCH {} : self.bchstring {} {}'.format(self.calculatedBCH,self.bchstring,self.calculatedBCH==self.bchstring)])
##Compare to the BCH in the beacon message
bcherr = self.BCHerrors = Func.errors(self.calculatedBCH,
self.bits[203:])
if bcherr > 0:
bcherror = 'ERROR! COMPUTED BCH DOES NOT MATCH ENCODED BCH!!'
self.errors.append(bcherror)
else:
bcherror = 'VALID BCH: COMPUTED BCH MATCHES'
self.tablebin.append(['', '', '', bcherror])
elif len(self.bits) == 203:
# if user enters a hex 51 excluding bch, then this ,means 202 information bits plus stub 0 minues the 2 digits of front padding
self.tablebin.append([
'203-250', 'NA', 'Encoded BCH',
'Not provided in a 51 Hex. Computed below'
])
self.calculatedBCH = Func.calcBCH(self.bits[1:], 0, 202, 250)
hexBCH = Func.bin2hex(self.calculatedBCH)
self.tablebin.append([
'203-250', self.calculatedBCH, 'Calculated BCH',
'Hex Value: {}'.format(hexBCH)
])
self.tablebin.append([
'Complete Message', '',
'Hex Value: {}{}'.format(self.inputhex, hexBCH), ''
])
elif len(self.bits) == 92:
self.type = 'uin'
##Add an additional bit to ensure that bits in array line up with bits in documentation
self.bits = "0" + self.bits
self.latitude = self.longitude = 'No data available'
self.tablebin.append(['Unique ID', 'Second Generation', '', ''])
self.tablebin.append([
'1', self.bits[1], 'SGB requires this bit value be 1',
['ERROR', 'OK'][int(self.bits[1])]
])
if self.bits[1] == '0':
self.validhex = False
self.errors.append(
'Error: SGB beacon UIN fixed first bit not set to 1')
##BIT 2-11 Country code
self.countryCode = Func.bin2dec(self.bits[2:12])
self.countryName = Func.countryname(self.countryCode)
if self.countryName == 'Unknown MID':
self.validhex = False
self.errors.append('Error: Bad country code: ' +
self.countryName)
self.tablebin.append([
'2-11', self.bits[2:12], 'Country code:',
str(self.countryCode) + ' ' + str(self.countryName),
definitions.moreinfo['country_code']
])
##BIT 12-14 Should be 101 status check for SGB
if self.bits[12:15] == '101':
status_check = 'OK'
else:
status_check = 'ERROR'
self.validhex = False
self.errors.append('Error: Bits 12-14 should be 101')
self.tablebin.append(
['12-14', self.bits[12:15], 'Should be 101', status_check])
##BIT 15-30 Type Approval Certificate #
self.tac = Func.bin2dec(self.bits[15:31])
if self.tac < 10000:
warn = 'Type Approval # {} :: WARNING! SGB specifications requires TAC No >=10,000'.format(
self.tac)
self.validhex = False
self.errors.append(warn)
else:
warn = str(self.tac)
self.tablebin.append(
['15-30', self.bits[15:31], 'Type Approval Cert No: ', warn])
##BIT 31-44 Beacon Serial Number
self.SerialNum = Func.bin2dec(self.bits[31:45])
self.tablebin.append([
'31-44', self.bits[35:45], 'Beacon serial number',
str(self.SerialNum)
])
self.testprotocol = Func.testProtocol(self.bits[45])
self.tablebin.append([
'45', self.bits[45], 'Test protocol flag:',
str(self.testprotocol)
])
if self.bits[45] == '1':
self.validhex = False
if self.bits[61:] == '0' * 32 and self.bits[46:49] != '111':
self.tablebin.append([
'46-48', self.bits[46:49], 'Vessel ID Type',
Func.getVesselid(self.bits[46:49])
])
self.tablebin.append([
'49-60', self.bits[49:61], 'Partial vessel ID',
'WARNING!! = No Identification information or truncated SGB 15 Hex (incomplete partial vessel ID. '
])
self.tablebin.append(
['61-92', self.bits[61:], 'Remaining bits', ''])
#self.vesselIDfill(46, self.bits[46:93])
else:
##BIT 45-91 Aircraft / Vessel ID
self.vesselIDfill(45, self.bits[46:93])
##T018 Iss.1 Rev 4 removed : (was BIT 92 Fixed value 1)
'''
if self.bits[92]=='1':
status_check = 'OK'
else:
status_check = 'ERROR'
self.tablebin.append(['92',
self.bits[92],
'Fixed 1',
status_check])
'''
else:
self.type = (
'Hex string length of ' + str(len(strhex)) + '.' +
'\nBit string length of ' + str(len(self.bits)) + '.' +
'\nLength of First Gen Beacon Hex String must be 15, 22 or 30'
+
'\nLength of Second Gen Beacon Bit String must be 204 or 252 bits'
)
raise Gen2Error('LengthError', self.type)
def processHex(self, strhex):
##All second generation beacon messages must be EXACTLY 250 bits
##in length for the program to function properly.
self.bits = Func.hex2bin(strhex)
if len(self.bits) == 250 or len(self.bits) == 202:
self.tablebin = []
self.rotatingbin = []
##Add an additional bit to ensure that bits in array line up with bits in documentation
self.bits = "0" + self.bits
##BIT 1-20 Type Approval Certificate #
self.tac = Func.bin2dec(self.bits[1:21])
self.tablebin.append([
'1-20', self.bits[1:21], 'Type Approval Certificate #:',
str(self.tac)
])
##BIT 21-30 Serial Number
self.serialNum = Func.bin2dec(self.bits[21:31])
self.tablebin.append([
'21-30', self.bits[21:31], 'Serial Number:',
str(self.serialNum)
])
##BIT 31-40 Country code
self.countryCode = Func.bin2dec(self.bits[31:41])
self.countryName = Func.countryname(self.countryCode)
self.tablebin.append([
'31-40', self.bits[31:41], 'Country code:',
str(self.countryCode) + ' ' + str(self.countryName)
])
##BIT 41 Status of homing device
self.status = Func.homing(self.bits[41])
self.tablebin.append(
['41', self.bits[41], 'Status of homing device:', self.status])
##BIT 42 Self-test function
self.selfTestStatus = Func.selfTest(self.bits[42])
self.tablebin.append([
'42', self.bits[42], 'Self-test function:', self.selfTestStatus
])
##BIT 43 User cancellation
self.cancel = Func.cancellation(self.bits[43])
self.tablebin.append(
['43', self.bits[43], 'User cancellation:', self.cancel])
##BIT 44-90 Encoded GNSS location
self.latitude = Func.getlatitude(self.bits[44:67])
self.tablebin.append(
['44-66', self.bits[44:67], 'Latitude:', self.latitude[0]])
self.longitude = Func.getlongitude(self.bits[67:91])
self.tablebin.append(
['67-90', self.bits[67:91], 'Longitude:', self.longitude[0]])
self.location = (self.latitude[1], self.longitude[1])
################################
# #
# BIT 91-137 VESSEL ID FIELD #
# #
################################
self.vesselID = self.bits[91:94]
##############################################
# Vessel 0: No aircraft or maritime identity #
##############################################
if self.vesselID == '000':
self.tablebin.append([
'91-93', self.bits[91:94], 'Vessel ID:',
'No aircraft or maritime identity'
])
if Func.checkzeros(self.bits[94:138]):
self.tablebin.append(
['94-137', self.bits[94:138], 'Spare:', 'All 0 - OK'])
else:
self.tablebin.append([
'94-137', self.bits[94:138], 'Spare:',
'ERROR: Bits 94-137 should be 0'
])
###########################
# Vessel 1: Maritime MMSI #
###########################
elif self.vesselID == '001':
self.tablebin.append(
['91-93', self.bits[91:94], 'Vessel ID:', 'MMSI'])
self.mmsi = Func.bin2dec(self.bits[94:124])
if self.mmsi == 111111:
self.tablebin.append([
'94-123', self.bits[94:124], 'MMSI:',
'No MMSI available'
])
else:
self.mmsi_string = str(self.mmsi).zfill(9)
self.tablebin.append([
'94-123', self.bits[94:124],
'Unique ship station identity M1I2D3X4X5X6X7X8X9:',
self.mmsi_string
])
self.mmsi_country = Func.countryname(
int(self.mmsi_string[0:3]))
self.tablebin.append([
'', '', 'Flag state of vessel:',
self.mmsi_string[0:3] + ' ' + self.mmsi_country
])
self.tablebin.append([
'', '', 'Unique vessel number:', self.mmsi_string[3:]
])
self.epirb_ais = Func.bin2dec(self.bits[124:138])
if self.epirb_ais == 10922:
self.tablebin.append([
'124-137', self.bits[124:138],
'EPIRB-AIS System Identity:', 'No EPIRB-AIS System'
])
else:
self.epirb_ais_str = str(self.epirb_ais).zfill(4)
self.epirb_ais_str = '974' + self.mmsi_string[
3:5] + self.epirb_ais_str
self.tablebin.append([
'124-137', self.bits[123:137],
'EPIRB-AIS System Identity:', self.epirb_ais_str
])
#############################
# Vessel 2: Radio Call Sign #
#############################
elif self.vesselID == '010':
self.tablebin.append([
'91-93', self.bits[91:94], 'Vessel ID:', 'Radio Call Sign'
])
self.callsign = Func.getCallsign(self.bits[94:136])
self.tablebin.append([
'94-135', self.bits[94:136], 'Radio Callsign:',
self.callsign
])
if Func.checkzeros(self.bits[136:138]):
self.tablebin.append([
'136-137', self.bits[136:138], 'Spare:', 'All 0 - OK'
])
else:
self.tablebin.append([
'136-137', self.bits[136:138], 'Spare:',
'ERROR: Bits 136-137 should be all 0s'
])
#########################################################
# Vessel 3: Aricraft Registration Marking (Tail Number) #
#########################################################
elif self.vesselID == '011':
self.tablebin.append([
'91-93', self.bits[91:94], 'Vessel ID:',
'Aircraft Registration Marking (Tail Number)'
])
self.tailnum = Func.getTailNum(self.bits[94:136])
self.tablebin.append([
'94-135', self.bits[94:136],
'Aircraft Registration Marking:', self.tailnum
])
if Func.checkzeros(self.bits[135:137]):
self.tablebin.append(
['136-137', self.bits[136:138], 'Spare:', 'OK'])
else:
self.tablebin.append([
'136-137', self.bits[136:138], 'Spare:',
'ERROR: Bits 136-137 should be all 0s'
])
##############################################
# Vessel 4: Aircraft Aviation 24 Bit Address #
##############################################
elif self.vesselID == '100':
self.tablebin.append([
'91-93', self.bits[91:94], 'Vessel ID:',
'Aircraft Aviation 24 Bit Address'
])
self.aviationBitAddress = Func.bin2dec(self.bits[93:117])
self.tablebin.append([
'94-117', self.bits[94:118], 'Aviation 24 bit address:',
str(self.aviationBitAddress)
])
if Func.checkzeros(self.bits[117:137]):
self.tablebin.append(
['118-137', self.bits[118:138], 'Spare:', 'OK'])
else:
self.tablebin.append([
'118-137', self.bits[118:138], 'Spare:',
'ERROR: Bits 118-137 following aviation 24 bit address should be 0'
])
#################################################
# Vessel 5: Aircraft Operator and Serial Number #
#################################################
elif self.vesselID == '101':
self.tablebin.append([
'91-93', self.bits[91:94], 'Vessel ID:',
'Aircraft Operator and Serial Number'
])
self.operator = Func.baudot2str(self.bits[94:112], 3)
self.serialnum = Func.bin2dec(self.bits[112:124])
self.tablebin.append([
'94-111', self.bits[94:112], 'Aircraft operator:',
self.operator
])
self.tablebin.append([
'112-123', self.bits[112:124], 'Serial number:',
str(self.serialnum)
])
if Func.checkones(self.bits[124:138]):
self.tablebin.append(
['124-137', self.bits[124:138], 'Spare:', 'OK'])
else:
self.tablebin.append([
'124-137', self.bits[124:138], 'Spare:',
'ERROR: Bits 124-137 following aircraft operator and serial numbers should be 1'
])
##########################
# Other Vessel IDs Spare #
##########################
else:
self.tablebin.append(
['91-93', self.bits[91:94], 'Vessel ID:', 'Spare'])
##BIT 138-154 Spare bits [137-153]
if Func.checkones(self.bits[138:155]):
self.tablebin.append(
['138-154', self.bits[138:155], 'Spare:', 'OK'])
else:
self.tablebin.append([
'138-154', self.bits[138:155], 'Spare:',
'ERROR: Bits 138-154 should be 1s'
])
#######################################
# #
# BIT 155-202 48 BIT ROTATING FIELD #
# #
#######################################
self.rotatingID = Func.bin2dec(self.bits[155:159])
######################################################
# Rotating Field 0: C/S G.008 Objective Requirements #
######################################################
if self.rotatingID == 0:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:',
'(#0) C/S G.008 Objective Requirements'
])
self.rotatingbin = rotating.rotating0(self.bits[155:203])
########################################
# Rotating Field 1: Inflight Emergency #
########################################
elif self.rotatingID == 1:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#1) Inflight Emergency'
])
self.rotatingbin = rotating.rotating1(self.bits[155:203])
#########################
# Rotating Field 2: RLS #
#########################
elif self.rotatingID == 2:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#2) RLS'
])
self.rotatingbin = rotating.rotating2(self.bits[155:203])
##################################
# Rotating Field 3: National Use #
##################################
elif self.rotatingID == 3:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#3) National Use'
])
self.rotatingbin = rotating.rotating3(self.bits[155:203])
###########################################
# Rotating Field 15: Cancellation Message #
###########################################
elif self.rotatingID == 15:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#15) Cancellation Message'
])
self.rotatingbin = rotating.rotating15(self.bits[155:203])
##################################
# All other roating fields spare #
##################################
else:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', 'Spare'
])
##Add rotating field data to our list
self.tablebin.extend(self.rotatingbin)
####################
# BEACON 23 HEX ID #
####################
self.hexID = []
##Hex ID BIT 1 = fixed binary 1
self.hexID.append('1')
##Hex ID BIT 2-11 = BITS 31-40 (C/S Country Code)
self.hexID.append(self.bits[31:41])
##Hex ID BIT 12 = fixed binary 1
self.hexID.append('1')
##Hex ID BIT 13 = fixed binary 0
self.hexID.append('0')
##Hex ID BIT 14 = fixed binary 1
self.hexID.append('1')
##Hex ID BIT 15-34 = BITS 1-20 (C/S TAC No)
self.hexID.append(self.bits[1:21])
##Hex ID BIT 35-44 = BITS 21-30 (Beacon Serial Number)
self.hexID.append(self.bits[21:31])
##Hex ID BIT 45-47 = BITS 91-93 (Aircraft/Vessel ID Type)
self.hexID.append(self.bits[91:94])
##Hex ID BIT 48-91 = BITS 94-137 (Aircraft/Vessel ID)
self.hexID.append(self.bits[94:138])
##Hex ID BIT 92 = fixed binary 1
self.hexID.append('1')
##Join list together and convert to Hexadecimal
self.beaconHexID = Func.bin2hex(''.join(self.hexID))
##Add the 23 Hex ID to our table
self.tablebin.append(
['', '', 'Beacon 23 Hex ID:', self.beaconHexID])
####################################
# 48-BIT BCH ERROR CORRECTING CODE #
####################################
if len(self.bits) == 251:
##Calculate the BCH
self.calculatedBCH = Func.calcBCH(self.bits[1:], 0, 202, 250)
##Compare to the BCH in the beacon message
self.BCHerrors = Func.errors(self.calculatedBCH,
self.bits[203:])
##Write the number of errors to our table
self.tablebin.append(
['', '', 'Number of BCH errors:',
str(self.BCHerrors)])
else:
self.type = (
'Hex string length of ' + str(len(strhex)) + '.' +
'\nBit string length of ' + str(len(self.bits)) + '.' +
'\nLength of First Gen Beacon Hex String must be 15, 22 or 30'
+ '\nLength of Second Gen Beacon Bit String must be 250 bits')
raise Gen2Error('LengthError', self.type)
correctedbch = '' #decodefunctions.dec2bin(ecc[0])
for e in ecc:
binchar = Fcn.dec2bin(e).zfill(8)
# #print(e, binchar)
correctedbch = correctedbch + binchar
return (bitflips,newdata,correctedbch)
if __name__ == "__main__":
mainmsg= input("Main msg: ")
bchsgb= input("BCH SGB: ")
if not mainmsg:
mainmsg='0000000000001110011010001111010011001001100001100001100101100001100010001010000001000111110000000000000000000000000000000000000000000000011111111111111111000000000100000000110000011010000000001001011000'
bchsgb='101010110000011010101010101010010101111010111001'
calculatedBCH = Sgb.calcBCH(mainmsg, 0, 202, 250)
#print(bchsgb)
#print(bchsgb==calculatedBCH)
#testhex='00E608F4C986196188A047C000000000000FFFC0100C1A00960'
#m = (Fcn.hextobin(testhex))
#print(len(m),m)
#calculatedBCH = Sgb.calcBCH(m, 0, 202, 250)
#print(calculatedBCH,len(calculatedBCH))
#print(len(mainmsg),len(bchsgb))
#print(calculatedBCH=='010010010010101001001111110001010111101001001001')
#data=bytearray(os.urandom(26))
#rebuildmsg=''
#for e in range(len(data)):
# segment = Fcn.dec2bin(data[e]).zfill(8)
# rebuildmsg = rebuildmsg + segment
bits_serialnum + \
bits_countrycode + \
bits_status + \
bits_selftest + \
bits_cancel + \
bits_latitude + \
bits_longitude + \
vessel_bits + \
bits_spare
####################################################################################################################################################################################
testbits = bits_maininfo + rotatingfield
bchbase = bits_maininfo + rotatingfield
BCH = Func2.calcBCH(bchbase, 0, 202, 250)
bch2 = wirtebch.calcBCH(bchbase,0,202,250)
print BCH == bch2
print bchbase
print BCH
print bch2
testhex = Func2.bin2hex(bchbase + BCH + '00')
printtxt('\nYour complete beacon message is: ' + testhex)
fhex.write('\n'+testhex)
try:
else:
print '\nRotating Field Type: Spare'
bits_rotating4 = bits_rotatingID + ('0' * 44)
rotatingfield = bits_rotating4
bits_maininfo = bits_tac + bits_serialnum + bits_countrycode + bits_status + bits_selftest + bits_cancel + bits_latitude + bits_longitude + vessel_bits + bits_spare
testbits = bits_maininfo + rotatingfield
BCH = Func2.calcBCH(testbits, 0, 202, 250)
testbits = testbits + BCH
testhex = Func2.bin2hex('00' + testbits)
print '\nYour beacon message is: ' + testhex
newBeacon1 = Gen2.SecondGen(testhex)
newBeacon1.processHex(testhex)
##Add BCH to export file
newBeacon1.tablebin.append(['203-250',
newBeacon1.bits[203:],
def processHex(self, strhex):
##All second generation beacon messages must be EXACTLY 250 bits
##in length for the program to function properly.
self.bits = Func.hex2bin(strhex)
self.tablebin = []
self.rotatingbin = []
if len(self.bits) == 252 or len(self.bits) == 202 or len(
self.bits) == 204 or len(self.bits) == 250:
##Add an additional bit to ensure that bits in array line up with bits in documentation
self.bits = "0" + self.bits
##BIT 1-20 Type Approval Certificate #
self.tac = Func.bin2dec(self.bits[1:21])
self.tablebin.append([
'1-20', self.bits[1:21], 'Type Approval Certificate #:',
str(self.tac)
])
##BIT 21-30 Serial Number
self.serialNum = Func.bin2dec(self.bits[21:31])
self.tablebin.append([
'21-30', self.bits[21:31], 'Serial Number:',
str(self.serialNum)
])
##BIT 31-40 Country code
self.countryCode = Func.bin2dec(self.bits[31:41])
self.countryName = Func.countryname(self.countryCode)
self.tablebin.append([
'31-40', self.bits[31:41], 'Country code:',
str(self.countryCode) + ' ' + str(self.countryName)
])
##BIT 41 Status of homing device
self.status = Func.homing(self.bits[41])
self.tablebin.append(
['41', self.bits[41], 'Status of homing device:', self.status])
##BIT 42 Self-test function
self.selfTestStatus = Func.selfTest(self.bits[42])
self.tablebin.append([
'42', self.bits[42], 'Self-test function:', self.selfTestStatus
])
##BIT 43 User cancellation
self.cancel = Func.cancellation(self.bits[43])
self.tablebin.append(
['43', self.bits[43], 'User cancellation:', self.cancel])
##BIT 44-90 Encoded GNSS location
self.latitude = Func.getlatitude(self.bits[44:67])
self.tablebin.append(
['44-66', self.bits[44:67], 'Latitude:', self.latitude[0]])
self.longitude = Func.getlongitude(self.bits[67:91])
self.tablebin.append(
['67-90', self.bits[67:91], 'Longitude:', self.longitude[0]])
self.location = (self.latitude[1], self.longitude[1])
################################
# #
# BIT 91-137 VESSEL ID FIELD #
# #
################################
self.vesselIDfill(0, self.bits[91:138])
##BIT 138-154 Spare bits [137-154]
if Func.checkones(self.bits[138:155]):
self.tablebin.append(
['138-154', self.bits[138:155], 'Spare:', 'OK'])
else:
self.tablebin.append([
'138-154', self.bits[138:155], 'Spare:',
'ERROR: Bits 138-154 should be 1s'
])
#######################################
# #
# BIT 155-202 48 BIT ROTATING FIELD #
# #
#######################################
self.rotatingID = Func.bin2dec(self.bits[155:159])
######################################################
# Rotating Field 0: C/S G.008 Objective Requirements #
######################################################
if self.rotatingID == 0:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:',
'(#0) C/S G.008 Objective Requirements'
])
self.rotatingbin = rotating.rotating0(self.bits[155:203])
########################################
# Rotating Field 1: Inflight Emergency #
########################################
elif self.rotatingID == 1:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#1) Inflight Emergency'
])
self.rotatingbin = rotating.rotating1(self.bits[155:203])
#########################
# Rotating Field 2: RLS #
#########################
elif self.rotatingID == 2:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#2) RLS'
])
self.rotatingbin = rotating.rotating2(self.bits[155:203])
##################################
# Rotating Field 3: National Use #
##################################
elif self.rotatingID == 3:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#3) National Use'
])
self.rotatingbin = rotating.rotating3(self.bits[155:203])
###########################################
# Rotating Field 15: Cancellation Message #
###########################################
elif self.rotatingID == 15:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', '(#15) Cancellation Message'
])
self.rotatingbin = rotating.rotating15(self.bits[155:203])
##################################
# All other roating fields spare #
##################################
else:
self.tablebin.append([
'155-158 (Rotating field 1-4)', self.bits[155:159],
'Rotating Field Type:', 'Spare'
])
##Add rotating field data to our list
self.tablebin.extend(self.rotatingbin)
####################
# BEACON 23 HEX ID #
####################
self.hexID = []
##Hex ID BIT 1 = fixed binary 1
self.hexID.append('1')
##Hex ID BIT 2-11 = BITS 31-40 (C/S Country Code)
self.hexID.append(self.bits[31:41])
##Hex ID BIT 12 = fixed binary 1
self.hexID.append('1')
##Hex ID BIT 13 = fixed binary 0
self.hexID.append('0')
##Hex ID BIT 14 = fixed binary 1
self.hexID.append('1')
##Hex ID BIT 15-34 = BITS 1-20 (C/S TAC No)
self.hexID.append(self.bits[1:21])
##Hex ID BIT 35-44 = BITS 21-30 (Beacon Serial Number)
self.hexID.append(self.bits[21:31])
##Hex ID BIT 45-47 = BITS 91-93 (Aircraft/Vessel ID Type)
self.hexID.append(self.bits[91:94])
##Hex ID BIT 48-91 = BITS 94-137 (Aircraft/Vessel ID)
self.hexID.append(self.bits[94:138])
##Hex ID BIT 92 = fixed binary 1
self.hexID.append('1')
##Join list together and convert to Hexadecimal
self.beaconHexID = Func.bin2hex(''.join(self.hexID))
##Add the 23 Hex ID to our table
self.tablebin.append(
['', '', 'Beacon 23 Hex ID:', self.beaconHexID])
####################################
# 48-BIT BCH ERROR CORRECTING CODE #
####################################
if len(self.bits) == 253:
self.tablebin.append(
['203-204 (padding)', self.bits[203:205], '', ''])
self.tablebin.append([
'205: (bch)', self.bits[205:], 'Encoded BCH', 'Encoded BCH'
])
##Calculate the BCH
self.calculatedBCH = Func.calcBCH(self.bits[1:], 0, 202, 250)
self.tablebin.append(
['Calculated', self.calculatedBCH, 'Computed', ''])
##Compare to the BCH in the beacon message
self.BCHerrors = Func.errors(self.calculatedBCH,
self.bits[205:])
##Write the number of errors to our table
self.tablebin.append(
['', '', 'Number of BCH errors:',
str(self.BCHerrors)])
elif len(self.bits) == 92:
self.type = (
'Hex string length of {}. \nBit length of {}. \nThis is a second generation beacon UIN'
.format(str(len(strhex)), str(len(self.bits))))
##Add an additional bit to ensure that bits in array line up with bits in documentation
self.bits = "0" + self.bits
self.tablebin.append(['Unique ID', 'Second Generation', '', ''])
self.tablebin.append([
'1', self.bits[1], 'should be 1', ['ERROR',
'OK'][int(self.bits[1])]
])
##BIT 2-11 Country code
self.countryCode = Func.bin2dec(self.bits[2:12])
self.countryName = Func.countryname(self.countryCode)
self.tablebin.append([
'2-11', self.bits[2:12], 'Country code:',
str(self.countryCode) + ' ' + str(self.countryName)
])
##BIT 12-14 Should be 101
if self.bits[12:15] == '101':
status_check = 'OK'
else:
status_check = 'ERROR'
self.tablebin.append(
['12-14', self.bits[12:15], 'Should be 101', status_check])
##BIT 15-34 Type Approval Certificate #
self.tac = Func.bin2dec(self.bits[15:35])
self.tablebin.append([
'15-34', self.bits[15:35], 'Type Approval Certificate #',
str(self.tac)
])
##BIT 35-44 Beacon Serial Number
self.serialNum = Func.bin2dec(self.bits[35:45])
self.tablebin.append([
'35-44', self.bits[35:45], 'Serial Number',
str(self.serialNum)
])
##BIT 45-91 Aircraft / Vessel ID
self.vesselIDfill(46, self.bits[45:92])
##BIT 92 Fixed value 1
self.tablebin.append(
['92', self.bits[92], 'Fixed 1', self.bits[92] == '1'])
else:
self.type = (
'Hex string length of ' + str(len(strhex)) + '.' +
'\nBit string length of ' + str(len(self.bits)) + '.' +
'\nLength of First Gen Beacon Hex String must be 15, 22 or 30'
+ '\nLength of Second Gen Beacon Bit String must be 250 bits')
raise Gen2Error('LengthError', self.type)