umdbpp / packetraven Goto Github PK

View Code? Open in Web Editor NEW

3.0 4.0 0.0 12.88 MB

track high-altitude balloon telemetry from a variety of sources

Home Page: https://packetraven.readthedocs.io

License: GNU General Public License v3.0

Rust 100.00%

aprs tnc high-altitude-balloon sondehub

packetraven's Introduction

PacketRaven

PacketRaven is a command-line dashboard that retrieves location telemetry sent by high-altitude balloon payloads. The program is designed to be run during a flight and display information in a terminal user interface (TUI):

Features

retrieves location telemetry from a variety of sources, including
- https://amateur.sondehub.org
- https://aprs.fi
- a TNC-equipped radio connected via USB
- a text file containing raw APRS frames
- a GeoJSON file with point geometries and telemetry
retrieves balloon flight predictions from https://predict.sondehub.org
plots variables such as altitude and ascent rate over time
estimates landing time (and, if doing a prediction, shows preficted landing location)

Instructions

Follow these instructions to create a new configuration file in a text editor, or use the following simple example:

# example.yaml
callsigns:
  - W3EAX-8
connections:
  sondehub: {}
  text:
    - path: http://bpp.umd.edu/archives/Launches/NS-111_2022_07_31/APRS/W3EAX-8%20raw.txt
    - port: COM3
      baud_rate: 9600

Download an executable from the Releases page.
Open a terminal window.
Run the executable you downloaded with start and a path to your configuration file:
```
packetraven.exe start example.yaml
```

Tip

Add --help to any command to show usage instructions.

Note

On MacOS or Linux, you may need to give the file executable permissions to run it:

chmod +x packetraven

You should now see the user interface. The program starts on the Log tab, which displays log messages. Use the up and down arrow keys to scroll.

Tip

Resize your terminal window, or zoom out / decrease the font size, as needed.

Upon first receiving new packet(s) from a callsign, a new tab will be created (shown in the top bar) for that callsign. Use the left and right arrow keys to switch between tabs.
While on a callsign tab, use the up and down arrow keys to switch between plots.
To quit, press q or Esc.

retrieve predictions

Run the executable with predict to retrieve a balloon flight prediction:

packetraven.exe predict "2023-08-16T10:00:00" -- -79 39 5 30000 9

Warning

due to a limitation in the argument parser, you must prepend all negative values with -- ; for instance, -79 should be -- -79

packetraven's People

Contributors

Stargazers

Watchers

packetraven's Issues

Improve handling of no internet

improve the user experience when internet connection is lost (inform the user / have descriptive error messages)

send Iridium packets to payload

@jtmolter

add APRS-IS igate functionality

send new packets from radio to APRS Internet Service (APRS-IS):
http://www.aprs-is.net/IGating.aspx

Integer overflow when determining large time to ground

2020-11-05 21:10:36,884 | INFO     | received 1 new packet(s) from https://api.aprs.fi/api/get: [APRSPacket(from_callsign='KC3HHV-7', to_callsign='APDR16', time=datetime.datetime(2020, 11, 5, 21, 10, 29), x=-76.851, y=39.16533, z=64.9224, crs=CRS.from_epsg(4326), path=['TCPIP*', 'qAC', 'FIFTH'], timestamp='1604628629', symbol='Z', symbol_table='/', comment='UMDBPP Recovery')]
2020-11-05 21:10:36,970 | INFO     | sending 1 packet(s) to postgres://128.8.202.13:5432/nearspace/testing: [APRSPacket(from_callsign='KC3HHV-7', to_callsign='APDR16', time=datetime.datetime(2020, 11, 5, 21, 10, 29), x=-76.851, y=39.16533, z=64.9224, crs=CRS.from_epsg(4326), path=['TCPIP*', 'qAC', 'FIFTH'], timestamp='1604628629', symbol='Z', symbol_table='/', comment='UMDBPP Recovery')]
Exception in Tkinter callback
Traceback (most recent call last):
  File "c:\program files\python38\lib\tkinter\__init__.py", line 1883, in __call__
    return self.func(*args)
  File "c:\program files\python38\lib\tkinter\__init__.py", line 804, in callit
    func(*args)
  File "c:\program files\python38\lib\site-packages\client\gui.py", line 500, in retrieve_packets
    parsed_packets = retrieve_packets(self.__connections, self.__packet_tracks, self.database, self.output_filename, self.start_date,
  File "c:\program files\python38\lib\site-packages\client\retrieve.py", line 82, in retrieve_packets
    if packet_track.time_to_ground >= timedelta(seconds=0):
  File "c:\program files\python38\lib\site-packages\packetraven\tracks.py", line 68, in time_to_ground
    return timedelta(seconds=self.packets[-1].coordinates[2] / current_ascent_rate)
OverflowError: Python int too large to convert to C int

`KeyError` when running GUI

GUI code expects a callsign window to exist, but it was never created

Descent predictions for NS-101 in the wrong location

see http://bpp.umd.edu/tracking/

in the image below, the per-callsign predictions (orange) should be at the end of the track (at the most recent packet) but instead are far south

make landing ellipse based on monte-carlo perturbation of descent prediction

while descending, calculate a landing ellipse based on possible variations of descent

should be 1 standard deviation, ideally

no output to `.geojson`

GeoJSON file is empty

Separate user-defined prediction track from predictions based on individual callsigns

when the user passes --prediction-start-time and --prediction-start-location, make an additional pseudo-track in the plot instead of the current behavior (which overrides all of the individual callsign predictions)

synchronize with database

upload and download new packets to PostGreSQL database table to keep it up-to-date with latest packets

Prediction perturber

Build a prediction perturber:

build perturber class
get sigma + bounds for prediction variables (launch location, launch time, avg. ascent rate, burst altitude, sea level descent rate, float altitude, float duration)
add a command line command

We're planning to do 4-6 launches between January 8th-17th, the first half will each be two single balloon launches near simultaneously, and the second half of those launches will be tandems for a float. We'll be launching out of Kessler Atmospheric and Ecological Field Station (somewhere around 34.980110, -97.521800 perhaps). Dr. Bowden can probably speak more about the prediction variables, I think they may want us to aim higher so ascend slower? I think we decided to aim for 9 AM launches too

Issues with building PyPROJ on Windows

When running pip install packetraven on a Windows machine, Pip will attempt to install PyPROJ from PyPI. However, since pyproj does not currently have a compiled Windows wheel on PyPI, the installation will fail unless the user has PROJ installed on their machine.

Display aprs.fi link in console to track specified callsigns

example URL:

https://aprs.fi/#!ts=1627131600&te=1627164000&call=a%2FW3EAX-11%2Ca%2FW3EAX-8%2Ca%2FW3EAX-9%2Ca%2FW3EAX-12

convert start and end time to epoch seconds
use selected callsogns
display at start of output so that user can get URL even if no connections are started

numpy sanity check fails on Windows build

https://developercommunity.visualstudio.com/content/problem/1207405/fmod-after-an-update-to-windows-2004-is-causing-a.html

Reduce clutter when printing new packet

When a new packet is received, the console currently prints the entire packet string, which piles up text

Instead of printing all of the packet details, print a short form instead

integrate Direwolf

implement Direwolf software TNC and IGate integration

https://github.com/wb2osz/direwolf

start and end dates do not propagate to existing plot window

Changes to the start and end times do not change a live plot window

edit LivePlot class:

PacketRaven/packetraven/gui/plotting.py

Lines 26 to 142 in be47f31

    
           class LivePlot: 
        
               def __init__( 
        
                   self, 
        
                   packet_tracks: {str: LocationPacketTrack}, 
        
                   variable: str, 
        
                   predictions: {str: PredictedTrajectory} = None, 
        
               ): 
        
                   if variable not in VARIABLES: 
        
                       raise NotImplementedError(f'unsupported plotting variable "{variable}"') 
        
                   self.packet_tracks = packet_tracks 
        
                   self.predictions = predictions if predictions is not None else {} 
        
                   self.variable = variable 
        
                   self.window.protocol('WM_DELETE_WINDOW', self.window.iconify) 
        
                   self.update() 
        
               def update( 
        
                   self, 
        
                   packet_tracks: {str: LocationPacketTrack} = None, 
        
                   predictions: {str: PredictedTrajectory} = None, 
        
               ): 
        
                   if packet_tracks is not None: 
        
                       self.packet_tracks.update(packet_tracks) 
        
                   if predictions is not None: 
        
                       self.predictions.update(predictions) 
        
                   if len(self.packet_tracks) > 0: 
        
                       if self.window.state() == 'iconic': 
        
                           self.window.deiconify() 
        
                       if self.window.focus_get() is None: 
        
                           self.window.focus_force() 
        
                       while len(self.axis.lines) > 0: 
        
                           self.axis.lines.pop(-1) 
        
                       packet_track_lines = {} 
        
                       for name, packet_track in self.packet_tracks.items(): 
        
                           lines = self.axis.plot( 
        
                               getattr(packet_track, VARIABLES[self.variable]['x']), 
        
                               getattr(packet_track, VARIABLES[self.variable]['y']), 
        
                               linewidth=2, 
        
                               marker='o', 
        
                               label=packet_track.name, 
        
                           ) 
        
                           packet_track_lines[name] = lines[0] 
        
                       for name, packet_track in self.predictions.items(): 
        
                           color = ( 
        
                               packet_track_lines[name].get_color() 
        
                               if name in packet_track_lines 
        
                               else None 
        
                           ) 
        
                           self.axis.plot( 
        
                               getattr(packet_track, VARIABLES[self.variable]['x']), 
        
                               getattr(packet_track, VARIABLES[self.variable]['y']), 
        
                               '--', 
        
                               linewidth=0.5, 
        
                               color=color, 
        
                               label=f'{packet_track.name} prediction', 
        
                           ) 
        
                       self.axis.legend() 
        
                       pyplot.draw() 
        
               @property 
        
               def window(self) -> Toplevel: 
        
                   return self.figure.canvas.manager.window 
        
               @property 
        
               def figure(self) -> Figure: 
        
                   try: 
        
                       figure = self.__figure 
        
                       if not pyplot.fignum_exists(figure.number): 
        
                           raise RuntimeError 
        
                   except (AttributeError, RuntimeError): 
        
                       figure = self.__new_figure() 
        
                   self.__figure = figure 
        
                   pyplot.show(block=False) 
        
                   return figure 
        
               @property 
        
               def axis(self) -> Axes: 
        
                   try: 
        
                       axis = self.__axis 
        
                       figure = axis.figure 
        
                       if figure is not self.figure: 
        
                           raise RuntimeError 
        
                   except (AttributeError, RuntimeError): 
        
                       axis = self.__new_axis() 
        
                   self.__axis = axis 
        
                   return axis 
        
               def __new_figure(self) -> Figure: 
        
                   x_label = VARIABLES[self.variable]['xlabel'] 
        
                   y_label = VARIABLES[self.variable]['ylabel'] 
        
                   return pyplot.figure(num=f'{y_label} / {x_label}') 
        
               def __new_axis(self, figure: Figure = None) -> Axes: 
        
                   if figure is None: 
        
                       figure = self.figure 
        
                   x_label = VARIABLES[self.variable]['xlabel'] 
        
                   y_label = VARIABLES[self.variable]['ylabel'] 
        
                   axis = figure.add_subplot(1, 1, 1) 
        
                   axis.set_xlabel(x_label) 
        
                   axis.set_ylabel(y_label) 
        
                   return axis 
        
               def close(self): 
        
                   pyplot.close(self.figure.number)

	class LivePlot:
	def __init__(
	self,
	packet_tracks: {str: LocationPacketTrack},
	variable: str,
	predictions: {str: PredictedTrajectory} = None,
	):
	if variable not in VARIABLES:
	raise NotImplementedError(f'unsupported plotting variable "{variable}"')

	self.packet_tracks = packet_tracks
	self.predictions = predictions if predictions is not None else {}
	self.variable = variable

	self.window.protocol('WM_DELETE_WINDOW', self.window.iconify)

	self.update()

	def update(
	self,
	packet_tracks: {str: LocationPacketTrack} = None,
	predictions: {str: PredictedTrajectory} = None,
	):
	if packet_tracks is not None:
	self.packet_tracks.update(packet_tracks)
	if predictions is not None:
	self.predictions.update(predictions)

	if len(self.packet_tracks) > 0:
	if self.window.state() == 'iconic':
	self.window.deiconify()
	if self.window.focus_get() is None:
	self.window.focus_force()

	while len(self.axis.lines) > 0:
	self.axis.lines.pop(-1)

	packet_track_lines = {}
	for name, packet_track in self.packet_tracks.items():
	lines = self.axis.plot(
	getattr(packet_track, VARIABLES[self.variable]['x']),
	getattr(packet_track, VARIABLES[self.variable]['y']),
	linewidth=2,
	marker='o',
	label=packet_track.name,
	)

	packet_track_lines[name] = lines[0]

	for name, packet_track in self.predictions.items():
	color = (
	packet_track_lines[name].get_color()
	if name in packet_track_lines
	else None
	)

	self.axis.plot(
	getattr(packet_track, VARIABLES[self.variable]['x']),
	getattr(packet_track, VARIABLES[self.variable]['y']),
	'--',
	linewidth=0.5,
	color=color,
	label=f'{packet_track.name} prediction',
	)

	self.axis.legend()
	pyplot.draw()

	@property
	def window(self) -> Toplevel:
	return self.figure.canvas.manager.window

	@property
	def figure(self) -> Figure:
	try:
	figure = self.__figure
	if not pyplot.fignum_exists(figure.number):
	raise RuntimeError
	except (AttributeError, RuntimeError):
	figure = self.__new_figure()
	self.__figure = figure
	pyplot.show(block=False)
	return figure

	@property
	def axis(self) -> Axes:
	try:
	axis = self.__axis
	figure = axis.figure
	if figure is not self.figure:
	raise RuntimeError
	except (AttributeError, RuntimeError):
	axis = self.__new_axis()
	self.__axis = axis
	return axis

	def __new_figure(self) -> Figure:
	x_label = VARIABLES[self.variable]['xlabel']
	y_label = VARIABLES[self.variable]['ylabel']

	return pyplot.figure(num=f'{y_label} / {x_label}')

	def __new_axis(self, figure: Figure = None) -> Axes:
	if figure is None:
	figure = self.figure

	x_label = VARIABLES[self.variable]['xlabel']
	y_label = VARIABLES[self.variable]['ylabel']

	axis = figure.add_subplot(1, 1, 1)
	axis.set_xlabel(x_label)
	axis.set_ylabel(y_label)

	return axis

	def close(self):
	pyplot.close(self.figure.number)