diff --git a/CMakeLists.txt b/CMakeLists.txt index c5c5373..5fa14e5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -116,6 +116,18 @@ link_directories( set(GR_GR-AIR-MODES_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include CACHE INTERNAL "" FORCE) set(GR_GR-AIR-MODES_SWIG_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/swig CACHE INTERNAL "" FORCE) +######################################################################## +# Create uninstall target +######################################################################## +configure_file( + ${CMAKE_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake +@ONLY) + +add_custom_target(uninstall + ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake +) + ######################################################################## # Add subdirectories ######################################################################## diff --git a/apps/get_dupes.py b/apps/get_dupes.py new file mode 100755 index 0000000..91fab13 --- /dev/null +++ b/apps/get_dupes.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python + +import sys, re + +if __name__== '__main__': + data = sys.stdin.readlines() + icaos = [] + num_icaos = 0 + for line in data: + match = re.match(".*Type.*from (\w+)", line) + if match is not None: + icao = int(match.group(1), 16) + icaos.append(icao) + + #get dupes + dupes = sorted([icao for icao in set(icaos) if icaos.count(icao) > 1]) + count = sum([icaos.count(icao) for icao in dupes]) + for icao in dupes: + print "%x" % icao + print "Found %i replies from %i non-unique aircraft, out of a total %i replies (%i likely spurious replies)." \ + % (count, len(dupes), len(icaos), len(icaos)-count) + + diff --git a/apps/modes_gui b/apps/modes_gui index af4d036..48368ed 100755 --- a/apps/modes_gui +++ b/apps/modes_gui @@ -423,23 +423,15 @@ class adsb_rx_block (gr.top_block): else: raise NotImplementedError - self.demod = gr.complex_to_mag() - self.avg = gr.moving_average_ff(100, 1.0/100, 400) - - self.preamble = air_modes.modes_preamble(int(rate), float(options["threshold"])) - self.slicer = air_modes.modes_slicer(int(rate), queue) + self.rx_path = air_modes.rx_path(rate, options["threshold"], queue) if use_resampler: self.lpfiltcoeffs = gr.firdes.low_pass(1, 5*3.2e6, 1.6e6, 300e3) self.resample = blks2.rational_resampler_ccf(interpolation=5, decimation=4, taps=self.lpfiltcoeffs) - self.connect(self.u, self.resample, self.demod) + self.connect(self.u, self.resample, self.rx_path) else: - self.connect(self.u, self.demod) + self.connect(self.u, self.rx_path) - self.connect(self.demod, self.avg) - self.connect(self.demod, (self.preamble, 0)) - self.connect(self.avg, (self.preamble, 1)) - self.connect(self.preamble, self.slicer) if __name__ == '__main__': app = QtGui.QApplication(sys.argv) diff --git a/apps/modes_rx b/apps/modes_rx index 9eba395..ff582f3 100755 --- a/apps/modes_rx +++ b/apps/modes_rx @@ -110,24 +110,14 @@ class adsb_rx_block (gr.top_block): if options.output_all : pass_all = 1 - self.demod = gr.complex_to_mag() - self.avg = gr.moving_average_ff(100, 1.0/100, 400) - - self.preamble = air_modes.modes_preamble(rate, options.threshold) - #self.framer = air_modes.modes_framer(rate) - self.slicer = air_modes.modes_slicer(rate, queue) + self.rx_path = air_modes.rx_path(rate, options.threshold, queue) if use_resampler: self.lpfiltcoeffs = gr.firdes.low_pass(1, 5*3.2e6, 1.6e6, 300e3) self.resample = blks2.rational_resampler_ccf(interpolation=5, decimation=4, taps=self.lpfiltcoeffs) - self.connect(self.u, self.resample, self.demod) + self.connect(self.u, self.resample, self.rx_path) else: - self.connect(self.u, self.demod) - - self.connect(self.demod, self.avg) - self.connect(self.demod, (self.preamble, 0)) - self.connect(self.avg, (self.preamble, 1)) - self.connect((self.preamble, 0), (self.slicer, 0)) + self.connect(self.u, self.rx_path) def tune(self, freq): result = self.u.set_center_freq(freq, 0) diff --git a/cmake/cmake_uninstall.cmake.in b/cmake/cmake_uninstall.cmake.in new file mode 100644 index 0000000..9ae1ae4 --- /dev/null +++ b/cmake/cmake_uninstall.cmake.in @@ -0,0 +1,32 @@ +# http://www.vtk.org/Wiki/CMake_FAQ#Can_I_do_.22make_uninstall.22_with_CMake.3F + +IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") + MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"") +ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") + +FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files) +STRING(REGEX REPLACE "\n" ";" files "${files}") +FOREACH(file ${files}) + MESSAGE(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"") + IF(EXISTS "$ENV{DESTDIR}${file}") + EXEC_PROGRAM( + "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" + OUTPUT_VARIABLE rm_out + RETURN_VALUE rm_retval + ) + IF(NOT "${rm_retval}" STREQUAL 0) + MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"") + ENDIF(NOT "${rm_retval}" STREQUAL 0) + ELSEIF(IS_SYMLINK "$ENV{DESTDIR}${file}") + EXEC_PROGRAM( + "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" + OUTPUT_VARIABLE rm_out + RETURN_VALUE rm_retval + ) + IF(NOT "${rm_retval}" STREQUAL 0) + MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"") + ENDIF(NOT "${rm_retval}" STREQUAL 0) + ELSE(EXISTS "$ENV{DESTDIR}${file}") + MESSAGE(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.") + ENDIF(EXISTS "$ENV{DESTDIR}${file}") +ENDFOREACH(file) diff --git a/lib/air_modes_slicer.cc b/lib/air_modes_slicer.cc index 48ea8b0..9c0bb7f 100644 --- a/lib/air_modes_slicer.cc +++ b/lib/air_modes_slicer.cc @@ -134,7 +134,7 @@ int air_modes_slicer::work(int noutput_items, slice_result_t slice_result = slicer(in[i+j*2], in[i+j*2+1], rx_packet.reference_level); if(slice_result.decision) pkt_hdr += 1 << (4-j); } - if(pkt_hdr == 17) rx_packet.type = Long_Packet; + if(pkt_hdr == 16 or pkt_hdr == 17 or pkt_hdr == 20 or pkt_hdr == 21) rx_packet.type = Long_Packet; else rx_packet.type = Short_Packet; int packet_length = (rx_packet.type == framer_packet_type(Short_Packet)) ? 56 : 112; diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt index 54bf701..a5ec50d 100644 --- a/python/CMakeLists.txt +++ b/python/CMakeLists.txt @@ -42,6 +42,7 @@ GR_PYTHON_INSTALL( parse.py msprint.py raw_server.py + rx_path.py sbs1.py sql.py Quaternion.py diff --git a/python/__init__.py b/python/__init__.py index f678ba1..dcdccc4 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -51,6 +51,7 @@ from air_modes_swig import * # import any pure python here # +from rx_path import rx_path from parse import parse,modes_reply from msprint import output_print from sql import output_sql diff --git a/python/cpr.py b/python/cpr.py index 1d647dd..c16289b 100755 --- a/python/cpr.py +++ b/python/cpr.py @@ -26,13 +26,9 @@ from air_modes.exceptions import * #the decoder is implemented as a class, cpr_decoder, which keeps state for local decoding. #the encoder is cpr_encode([lat, lon], type (even=0, odd=1), and surface (0 for surface, 1 for airborne)) -latz = 15 +#TODO: remove range/bearing calc from CPR decoder class. you can do this outside of the decoder. -def nbits(surface): - if surface == 1: - return 19 - else: - return 17 +latz = 15 def nz(ctype): return 4 * latz - ctype @@ -49,38 +45,30 @@ def dlat(ctype, surface): else: return tmp / nzcalc -def nl_eo(declat_in, ctype): - return nl(declat_in) - ctype - def nl(declat_in): if abs(declat_in) >= 87.0: return 1.0 - return math.floor( (2.0*math.pi) * pow(math.acos(1.0- (1.0-math.cos(math.pi/(2.0*latz))) / pow( math.cos( (math.pi/180.0)*abs(declat_in) ) ,2.0) ),-1.0)) + return math.floor( (2.0*math.pi) * math.acos(1.0- (1.0-math.cos(math.pi/(2.0*latz))) / math.cos( (math.pi/180.0)*abs(declat_in) )**2 )**-1) def dlon(declat_in, ctype, surface): - if surface == 1: + if surface: tmp = 90.0 else: tmp = 360.0 - nlcalc = nl_eo(declat_in, ctype) - if nlcalc == 0: - return tmp - else: - return tmp / max(nlcalc, 1.0) + nlcalc = max(nl(declat_in)-ctype, 1) + return tmp / nlcalc def decode_lat(enclat, ctype, my_lat, surface): tmp1 = dlat(ctype, surface) - tmp2 = float(enclat) / (2**nbits(surface)) + tmp2 = float(enclat) / (2**17) j = math.floor(my_lat/tmp1) + math.floor(0.5 + ((my_lat % tmp1) / tmp1) - tmp2) -# print "dlat gives " + "%.6f " % tmp1 + "with j = " + "%.6f " % j + " and tmp2 = " + "%.6f" % tmp2 + " given enclat " + "%x" % enclat return tmp1 * (j + tmp2) def decode_lon(declat, enclon, ctype, my_lon, surface): tmp1 = dlon(declat, ctype, surface) - tmp2 = float(enclon) / (2.0**nbits(surface)) + tmp2 = float(enclon) / (2**17) m = math.floor(my_lon / tmp1) + math.floor(0.5 + ((my_lon % tmp1) / tmp1) - tmp2) -# print "dlon gives " + "%.6f " % tmp1 + "with m = " + "%.6f " % m + " and tmp2 = " + "%.6f" % tmp2 + " given enclon " + "%x" % enclon return tmp1 * (m + tmp2) @@ -93,7 +81,11 @@ def cpr_resolve_local(my_location, encoded_location, ctype, surface): return [decoded_lat, decoded_lon] -def cpr_resolve_global(evenpos, oddpos, mostrecent, surface): +def cpr_resolve_global(evenpos, oddpos, mypos, mostrecent, surface): + #cannot resolve surface positions unambiguously without knowing receiver position + if surface and mypos is None: + raise CPRNoPositionError + dlateven = dlat(0, surface) dlatodd = dlat(1, surface) @@ -114,7 +106,6 @@ def cpr_resolve_global(evenpos, oddpos, mostrecent, surface): #This checks to see if the latitudes of the reports straddle a transition boundary #If so, you can't get a globally-resolvable location. if nl(rlateven) != nl(rlatodd): - #print "Boundary straddle!" raise CPRBoundaryStraddleError if mostrecent == 0: @@ -122,21 +113,41 @@ def cpr_resolve_global(evenpos, oddpos, mostrecent, surface): else: rlat = rlatodd - dl = dlon(rlat, mostrecent, surface) - nlthing = nl(rlat) - ni = max(nlthing - mostrecent, 1) + #disambiguate latitude + if surface: + if mypos[0] < 0: + rlat -= 90 - m = math.floor(((evenpos[1]*(nlthing-1)-oddpos[1]*(nlthing))/2**17)+0.5) #longitude index + dl = dlon(rlat, mostrecent, surface) + nl_rlat = nl(rlat) + + m = math.floor(((evenpos[1]*(nl_rlat-1)-oddpos[1]*nl_rlat)/2**17)+0.5) #longitude index + + #when surface positions straddle a disambiguation boundary (90 degrees), + #surface decoding will fail. this might never be a problem in real life, but it'll fail in the + #test case. the documentation doesn't mention it. if mostrecent == 0: enclon = evenpos[1] else: enclon = oddpos[1] - rlon = dl * (((ni+m) % ni)+enclon/2**17) + rlon = dl * ((m % max(nl_rlat-mostrecent,1)) + enclon/2.**17) + #print "DL: %f nl: %f m: %f rlon: %f" % (dl, nl_rlat, m, rlon) + #print "evenpos: %x, oddpos: %x, mostrecent: %i" % (evenpos[1], oddpos[1], mostrecent) + + if surface: + #longitudes need to be resolved to the nearest 90 degree segment to the receiver. + wat = mypos[1] + if wat < 0: + wat += 360 + zone = lambda lon: 90 * (int(lon) / 90) + rlon += (zone(wat) - zone(rlon)) + + #limit to (-180, 180) if rlon > 180: - rlon = rlon - 360.0 + rlon -= 360.0 return [rlat, rlon] @@ -174,6 +185,8 @@ class cpr_decoder: self.my_location = my_location self.evenlist = {} self.oddlist = {} + self.evenlist_sfc = {} + self.oddlist_sfc = {} def set_location(new_location): self.my_location = new_location @@ -183,24 +196,34 @@ class cpr_decoder: for key, item in poslist.items(): if time.time() - item[2] > 10: del poslist[key] + for poslist in [self.evenlist_sfc, self.oddlist_sfc]: + for key, item in poslist.items(): + if time.time() - item[2] > 25: + del poslist[key] def decode(self, icao24, encoded_lat, encoded_lon, cpr_format, surface): + if surface: + oddlist = self.oddlist_sfc + evenlist = self.evenlist_sfc + else: + oddlist = self.oddlist + evenlist = self.evenlist + #add the info to the position reports list for global decoding if cpr_format==1: - self.oddlist[icao24] = [encoded_lat, encoded_lon, time.time()] + oddlist[icao24] = [encoded_lat, encoded_lon, time.time()] else: - self.evenlist[icao24] = [encoded_lat, encoded_lon, time.time()] + evenlist[icao24] = [encoded_lat, encoded_lon, time.time()] [decoded_lat, decoded_lon] = [None, None] #okay, let's traverse the lists and weed out those entries that are older than 10 seconds self.weed_poslists() - if (icao24 in self.evenlist) \ - and (icao24 in self.oddlist): - newer = (self.oddlist[icao24][2] - self.evenlist[icao24][2]) > 0 #figure out which report is newer - [decoded_lat, decoded_lon] = cpr_resolve_global(self.evenlist[icao24][0:2], self.oddlist[icao24][0:2], newer, surface) #do a global decode - + if (icao24 in evenlist) \ + and (icao24 in oddlist): + newer = (oddlist[icao24][2] - evenlist[icao24][2]) > 0 #figure out which report is newer + [decoded_lat, decoded_lon] = cpr_resolve_global(evenlist[icao24][0:2], oddlist[icao24][0:2], self.my_location, newer, surface) #do a global decode else: raise CPRNoPositionError @@ -215,83 +238,95 @@ class cpr_decoder: #encode CPR position def cpr_encode(lat, lon, ctype, surface): if surface is True: - scalar = float(2**19) + scalar = 2.**19 else: - scalar = float(2**17) + scalar = 2.**17 - dlati = float(dlat(ctype, False)) + #encode using 360 constant for segment size. + dlati = dlat(ctype, False) yz = math.floor(scalar * ((lat % dlati)/dlati) + 0.5) rlat = dlati * ((yz / scalar) + math.floor(lat / dlati)) - nleo = nl_eo(rlat, ctype) - if nleo == 0: - dloni = 360.0 - else: - dloni = 360.0 / nl_eo(rlat, ctype) - + #encode using 360 constant for segment size. + dloni = dlon(lat, ctype, False) xz = math.floor(scalar * ((lon % dloni)/dloni) + 0.5) - yz = int(yz % scalar) - xz = int(xz % scalar) + yz = int(yz) & (2**17-1) + xz = int(xz) & (2**17-1) return (yz, xz) #lat, lon if __name__ == '__main__': import sys, random - - rounds = 10000 + + rounds = 10001 threshold = 1e-3 #0.001 deg lat/lon #this accuracy is highly dependent on latitude, since at high #latitudes the corresponding error in longitude is greater bs = 0 + surface = False + + lats = [i/(rounds/170.)-85 for i in range(0,rounds)] + lons = [i/(rounds/360.)-180 for i in range(0,rounds)] for i in range(0, rounds): - decoder = cpr_decoder(None) - even_lat = random.uniform(-85, 85) - even_lon = random.uniform(-180,180) - odd_lat = even_lat + 1e-2 - odd_lon = min(even_lon + 1e-2, 180) + even_lat = lats[i] + #even_lat = random.uniform(-85, 85) + even_lon = lons[i] + #even_lon = random.uniform(-180, 180) + odd_lat = even_lat + 1e-3 + odd_lon = min(even_lon + 1e-3, 180) + decoder = cpr_decoder([odd_lat, odd_lon]) #encode that position - (evenenclat, evenenclon) = cpr_encode(even_lat, even_lon, False, False) - (oddenclat, oddenclon) = cpr_encode(odd_lat, odd_lon, True, False) + (evenenclat, evenenclon) = cpr_encode(even_lat, even_lon, False, surface) + (oddenclat, oddenclon) = cpr_encode(odd_lat, odd_lon, True, surface) - #perform a global decode + #try to perform a global decode -- this should fail since the decoder + #only has heard one position. need two for global decoding. icao = random.randint(0, 0xffffff) try: - evenpos = decoder.decode(icao, evenenclat, evenenclon, False, False) - #print "CPR global decode with only one report: %f %f" % (evenpos[0], evenpos[1]) + evenpos = decoder.decode(icao, evenenclat, evenenclon, False, surface) raise Exception("CPR test failure: global decode with only one report") except CPRNoPositionError: pass + #now try to do a real decode with the last packet's odd complement + #watch for a boundary straddle -- this isn't fatal, it just indicates + #that the even and odd reports lie on either side of a longitudinal boundary + #and so you can't get a position try: - (odddeclat, odddeclon, rng, brg) = decoder.decode(icao, oddenclat, oddenclon, True, False) + (odddeclat, odddeclon, rng, brg) = decoder.decode(icao, oddenclat, oddenclon, True, surface) except CPRBoundaryStraddleError: bs += 1 continue except CPRNoPositionError: raise Exception("CPR test failure: no decode after even/odd inputs") - #print "Lat: %f Lon: %f" % (ac_lat, ac_lon) - if abs(odddeclat - odd_lat) > threshold or abs(odddeclon - odd_lon) > threshold: - print "odddeclat: %f odd_lat: %f" % (odddeclat, odd_lat) - print "odddeclon: %f odd_lon: %f" % (odddeclon, odd_lon) + print "F odddeclat: %f odd_lat: %f" % (odddeclat, odd_lat) + print "F odddeclon: %f odd_lon: %f" % (odddeclon, odd_lon) raise Exception("CPR test failure: global decode error greater than threshold") +# else: +# print "S odddeclat: %f odd_lat: %f" % (odddeclat, odd_lat) +# print "S odddeclon: %f odd_lon: %f" % (odddeclon, odd_lon) - nexteven_lat = odd_lat + 1e-2 - nexteven_lon = min(odd_lon + 1e-2, 180) + nexteven_lat = odd_lat + 1e-3 + nexteven_lon = min(odd_lon + 1e-3, 180) - (nexteven_enclat, nexteven_enclon) = cpr_encode(nexteven_lat, nexteven_lon, False, False) + (nexteven_enclat, nexteven_enclon) = cpr_encode(nexteven_lat, nexteven_lon, False, surface) + #try a locally-referenced decode try: - (evendeclat, evendeclon) = cpr_resolve_local([even_lat, even_lon], [nexteven_enclat, nexteven_enclon], False, False) + (evendeclat, evendeclon) = cpr_resolve_local([even_lat, even_lon], [nexteven_enclat, nexteven_enclon], False, surface) except CPRNoPositionError: raise Exception("CPR test failure: local decode failure to resolve") - + + #check to see if the positions were valid if abs(evendeclat - nexteven_lat) > threshold or abs(evendeclon - nexteven_lon) > threshold: + print "F evendeclat: %f nexteven_lat: %f evenlat: %f" % (evendeclat, nexteven_lat, even_lat) + print "F evendeclon: %f nexteven_lon: %f evenlon: %f" % (evendeclon, nexteven_lon, even_lon) raise Exception("CPR test failure: local decode error greater than threshold") print "CPR test successful. There were %i boundary straddles over %i rounds." % (bs, rounds) diff --git a/python/msprint.py b/python/msprint.py index 2349c35..bf54217 100644 --- a/python/msprint.py +++ b/python/msprint.py @@ -55,8 +55,8 @@ class output_print(air_modes.parse): output += self.print11(data, ecc) elif msgtype == 17: output += self.print17(data) - elif msgtype == 20 or msgtype == 21: - output += self.print20(data, ecc) + elif msgtype == 20 or msgtype == 21 or msgtype == 16: + output += self.printTCAS(data, ecc) else: output += "No handler for message type %i from %x (but it's in modes_parse)" % (msgtype, ecc) return output @@ -186,36 +186,48 @@ class output_print(air_modes.parse): return retstr - def print20(self, data, ecc): + def printTCAS(self, data, ecc): msgtype = data["df"] - if(msgtype == 20): + if msgtype == 20 or msgtype == 16: + #type 16 does not have fs, dr, um but we get alt here [fs, dr, um, alt] = self.parse4(data) - else: + elif msgtype == 21: [fs, dr, um, ident] = self.parse5(data) - bds1 = data["bds1"] - bds2 = data["bds2"] + + if msgtype == 16: + bds1 = data["vds1"] + bds2 = data["vds2"] + else: + bds1 = data["bds1"] + bds2 = data["bds2"] if bds2 != 0: - retstr = "No handler for BDS2 == %i from %x" % (bds2, ecc) + retstr = "No handler in type %i for BDS2 == %i from %x" % (msgtype, bds2, ecc) elif bds1 == 0: - retstr = "No handler for BDS1 == 0 from %x" % ecc + retstr = "No handler in type %i for BDS1 == 0 from %x" % (msgtype, ecc) elif bds1 == 1: - retstr = "Type 20 link capability report from %x: ACS: 0x%x, BCS: 0x%x, ECS: 0x%x, continues %i" \ - % (ecc, data["acs"], data["bcs"], data["ecs"], data["cfs"]) + retstr = "Type %i link capability report from %x: ACS: 0x%x, BCS: 0x%x, ECS: 0x%x, continues %i" \ + % (msgtype, ecc, data["acs"], data["bcs"], data["ecs"], data["cfs"]) elif bds1 == 2: - retstr = "Type 20 identification from %x with text %s" % (ecc, self.parseMB_id(data)) - elif bds2 == 3: - retstr = "Type 20 TCAS report from %x: " % ecc + retstr = "Type %i identification from %x with text %s" % (msgtype, ecc, self.parseMB_id(data)) + elif bds1 == 3: + retstr = "Type %i TCAS report from %x: " % (msgtype, ecc) tti = data["tti"] - if tti == 1: - (resolutions, complements, rat, mte, threat_id) = self.parseMB_TCAS_threatid(data) - retstr += "threat ID: %x advised: %s complement: %s" % (threat_id, resolutions, complements) - elif tti == 2: - (resolutions, complements, rat, mte, threat_alt, threat_range, threat_bearing) = self.parseMB_TCAS_threatloc(data) - retstr += "range: %i bearing: %i alt: %i advised: %s complement: %s" % (threat_range, threat_bearing, threat_alt, resolutions, complements) + if msgtype == 16: + (resolutions, complements, rat, mte) = self.parse_TCAS_CRM(data) + retstr += "advised: %s complement: %s" % (resolutions, complements) else: - retstr += " (no handler for TTI=%i)" % tti + if tti == 1: + (resolutions, complements, rat, mte, threat_id) = self.parseMB_TCAS_threatid(data) + retstr += "threat ID: %x advised: %s complement: %s" % (threat_id, resolutions, complements) + elif tti == 2: + (resolutions, complements, rat, mte, threat_alt, threat_range, threat_bearing) = self.parseMB_TCAS_threatloc(data) + retstr += "range: %i bearing: %i alt: %i advised: %s complement: %s" % (threat_range, threat_bearing, threat_alt, resolutions, complements) + else: + rat = 0 + mte = 0 + retstr += " (no handler for TTI=%i)" % tti if mte == 1: retstr += " (multiple threats)" if rat == 1: @@ -223,9 +235,9 @@ class output_print(air_modes.parse): else: retstr = "No handler for BDS1 == %i from %x" % (bds1, ecc) -# if(msgtype == 20): -# retstr += " at %ift" % altitude -# else: -# retstr += " ident %x" % ident + if(msgtype == 20 or msgtype == 16): + retstr += " at %ift" % alt + else: + retstr += " ident %x" % ident return retstr diff --git a/python/parse.py b/python/parse.py index 506aec0..353819c 100644 --- a/python/parse.py +++ b/python/parse.py @@ -193,6 +193,22 @@ class mb_reply(data_field): # "vds": (33,8), "vds1": (33,4), "vds2": (37,4) # } +class mv_reply(data_field): + offset = 33 + types = { "ara": (41,14), "mte": (60,1), "rac": (55,4), "rat": (59,1), + "vds": (33,8), "vds1": (33,4), "vds2": (37,4) + } + + def get_type(self): + vds1 = self.get_bits(33,4) + vds2 = self.get_bits(37,4) + if vds1 not in (3,) or vds2 not in (0,): + raise NoHandlerError(bds1) + return int(vds1) + + def get_numbits(self): + return 56 + #the whole Mode S packet type class modes_reply(data_field): types = { 0: {"df": (1,5), "vs": (6,1), "cc": (7,1), "sl": (9,3), "ri": (14,4), "ac": (20,13), "ap": (33,24)}, @@ -233,7 +249,7 @@ class parse: def parse11(self, data, ecc): interrogator = ecc & 0x0F - return [data["aa"], interrogator, data["ca"]] + return [data["aa"], interrogator, data["ca"]] categories = [["NO INFO", "RESERVED", "RESERVED", "RESERVED", "RESERVED", "RESERVED", "RESERVED", "RESERVED"],\ ["NO INFO", "SURFACE EMERGENCY VEHICLE", "SURFACE SERVICE VEHICLE", "FIXED OBSTRUCTION", "CLUSTER OBSTRUCTION", "LINE OBSTRUCTION", "RESERVED"],\ @@ -379,15 +395,16 @@ class parse: 53: "DON'T TURN LEFT", 54: "DON'T TURN RIGHT"} rac_bits = {55: "DON'T DESCEND", 56: "DON'T CLIMB", 57: "DON'T TURN LEFT", 58: "DON'T TURN RIGHT"} ara = data["ara"] + rac = data["rac"] #check to see which bits are set resolutions = "" - for bit, name in ara_bits: + for bit in ara_bits: if ara & (1 << (54-bit)): - resolutions += " " + name + resolutions += " " + ara_bits[bit] complements = "" - for bit, name in rac_bits: + for bit in rac_bits: if rac & (1 << (58-bit)): - complements += " " + name + complements += " " + rac_bits[bit] return (resolutions, complements) #rat is 1 if resolution advisory terminated <18s ago @@ -404,3 +421,8 @@ class parse: (resolutions, complements) = self.parseMB_TCAS_resolutions(data) threat_alt = decode_alt(data["tida"], True) return (resolutions, complements, data["rat"], data["mte"], threat_alt, data["tidr"], data["tidb"]) + + #type 16 Coordination Reply Message + def parse_TCAS_CRM(self, data): + (resolutions, complements) = self.parseMB_TCAS_resolutions(data) + return (resolutions, complements, data["rat"], data["mte"]) diff --git a/python/rx_path.py b/python/rx_path.py new file mode 100644 index 0000000..09d9a2f --- /dev/null +++ b/python/rx_path.py @@ -0,0 +1,50 @@ +# +# Copyright 2012 Corgan Labs +# +# This file is part of gr-air-modes +# +# gr-air-modes is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3, or (at your option) +# any later version. +# +# gr-air-modes is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with gr-air-modes; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, +# Boston, MA 02110-1301, USA. +# + +from gnuradio import gr +import air_modes_swig + +class rx_path(gr.hier_block2): + + def __init__(self, rate, threshold, queue): + gr.hier_block2.__init__(self, "modes_rx_path", + gr.io_signature(1, 1, gr.sizeof_gr_complex), + gr.io_signature(0,0,0)) + + self._rate = int(rate) + self._threshold = threshold + self._queue = queue + + # Convert incoming I/Q baseband to amplitude + self._demod = gr.complex_to_mag() + + # Establish baseline amplitude (noise, interference) + self._avg = gr.moving_average_ff(100, 1.0/100, 400) # FIXME + + # Synchronize to Mode-S preamble + self._sync = air_modes_swig.modes_preamble(self._rate, self._threshold) + + # Slice Mode-S bits and send to message queue + self._slicer = air_modes_swig.modes_slicer(self._rate, self._queue) + + self.connect(self, self._demod, (self._sync, 0)) + self.connect(self._demod, self._avg, (self._sync, 1)) + self.connect(self._sync, self._slicer)