def __init__(self, args, config):
self._args = args
self._config = config
self._log = logging.getLogger("App")
self._receiver_log = logging.getLogger("Receiver")
self._publisher_log = logging.getLogger("Publisher")
self._receiver = Receiver(args.downlink_host,
args.downlink_port,
on_stop=self._abort)
self._frame_decoder = response_frames.FrameDecoder(
response_frames.frame_factories)
self._receiver_thread = Thread(target=self._receiver_worker)
self._receiver_thread.setDaemon(True)
self._publisher_thread = Thread(target=self._publisher_worker)
self._receiver_thread.setDaemon(True)
self._abort_pub = zmq.Context.instance().socket(zmq.PAIR)
self._publisher_abort = zmq.Context.instance().socket(zmq.PAIR)
self._new_frame_push = zmq.Context.instance().socket(zmq.PUSH)
self._new_frame_pull = zmq.Context.instance().socket(zmq.PULL)
self._new_frame_push.bind("inproc://satnogs_uploader/new_msg")
self._new_frame_pull.connect("inproc://satnogs_uploader/new_msg")
self._abort_pub.bind("inproc://satnogs_uploader/abort")
self._publisher_abort.connect("inproc://satnogs_uploader/abort")
def __init__(self, args):
self._args = args
self._log = logging.getLogger("App")
self._receiver = Receiver(args.downlink_host, args.downlink_port)
self._frame_decoder = response_frames.FrameDecoder(
response_frames.frame_factories)
url = urlparse(args.influx)
self._db = InfluxDBClient(host=url.hostname,
port=url.port,
database=url.path.strip('/'))
def decode(raw_frame_payload):
frame_decoder = FallbackResponseDecorator(response_frames.FrameDecoder(response_frames.frame_factories))
frame_object = frame_decoder.decode(ensure_byte_list(raw_frame_payload))
if isinstance(frame_object, comm_beacon.BeaconFrame):
return ParseBeacon.convert(ParseBeacon.parse(frame_object))
elif isinstance(frame_object, response_frames.file_system.FileListSuccessFrame):
return ParseBeacon.parse_file_list(frame_object)
else:
return frame_object
def __init__(self, store, session_number):
self._store = store
self.session_number = session_number
self._root = path.join(store.root, 'sessions', str(session_number))
self._frame_decoder = FallbackResponseDecorator(
response_frames.FrameDecoder(response_frames.frame_factories))
self.tasklist_path = self.expand_path('tasklist.py')
self.tasklist = []
if path.exists(self.tasklist_path):
self.tasklist = store.load_tasklist(self.tasklist_path)
if self.has_artifact('all.frames'):
self.all_frames = self.frames(['all'])
def __init__(self,
mock_com,
enable_zmq,
grc_uplink_address="tcp://localhost:7002",
grc_downlink_address="tcp://localhost:7003",
uplink_per=0,
downlink_per=0):
self._mock_com = mock_com
self.i2c = I2CMock(mock_com)
import response_frames
from devices import EPS, Comm, AntennaController, Imtq, Gyro, RTCDevice
from devices import BACKUP_ANTENNA_CONTROLLER_ADDRESS, PRIMARY_ANTENNA_CONTROLLER_ADDRESS
self.frame_decoder = response_frames.FrameDecoder(
response_frames.frame_factories)
self.eps = EPS()
self.comm = Comm(self.frame_decoder)
self.transmitter = self.comm.transmitter
self.receiver = self.comm.receiver
self.primary_antenna = AntennaController(
PRIMARY_ANTENNA_CONTROLLER_ADDRESS, "Primary Antenna")
self.backup_antenna = AntennaController(
BACKUP_ANTENNA_CONTROLLER_ADDRESS, "Backup Antenna")
self.imtq = Imtq()
self.gyro = Gyro()
self.rtc = RTCDevice()
self.i2c.add_bus_device(self.eps.controller_a)
self.i2c.add_pld_device(self.eps.controller_b)
self.i2c.add_bus_device(self.transmitter)
self.i2c.add_bus_device(self.receiver)
self.i2c.add_bus_device(self.primary_antenna)
self.i2c.add_pld_device(self.backup_antenna)
self.i2c.add_bus_device(self.imtq)
self.i2c.add_pld_device(self.rtc)
self.i2c.add_pld_device(self.gyro)
if enable_zmq:
self.zmq_adapter = ZeroMQAdapter(
self.comm,
grc_uplink_address=grc_uplink_address,
grc_downlink_address=grc_downlink_address,
uplink_per=uplink_per,
downlink_per=downlink_per)
def __init__(self, args):
self.Decoder = response_frames.FrameDecoder(
response_frames.frame_factories)
ctx = zmq.Context.instance()
self.abort_push = ctx.socket(zmq.PAIR)
self.abort_pull = ctx.socket(zmq.PAIR)
self.command_socket = ctx.socket(zmq.REP)
self.command_bound = False
self.session = args.session
self.endpoints = args.address
self.port = args.port
self.mission_path = args.mission
self.ui = None
self.listening_sockets = None
self.download_tasks = None
self.abort_push.bind('inproc://download_monitor/abort')
self.abort_pull.connect('inproc://download_monitor/abort')
def make_frame(self, frame):
frame_decoder = FallbackResponseDecorator(
response_frames.FrameDecoder(response_frames.frame_factories))
return frame_decoder.decode(frame)
'--port',
required=True,
help="GNURadio port",
default=52001,
type=int)
args = parser.parse_args()
imp.load_source('config', args.config)
class MyPrompt(Prompts):
def in_prompt_tokens(self, cli=None):
return [(Token.Prompt, 'COMM'), (Token.Prompt, '> ')]
cfg = Config()
frame_decoder = FallbackResponseDecorator(
response_frames.FrameDecoder(response_frames.frame_factories))
def receive():
rcv = Receiver(args.target, args.port)
rcv.connect()
data = rcv.decode_kiss(rcv.receive())
rcv.disconnect()
return frame_decoder.decode(data)
shell = InteractiveShellEmbed(config=cfg,
user_ns={'receive': receive},
banner2='COMM Terminal')
shell.prompts = MyPrompt(shell)
shell.run_code('from telecommand import *')
shell()
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('downlink_frames',
help="Downlink frames with already done uploads (.frames file)")
parser.add_argument('tasklist', nargs='?',
help="Previous tasklist")
parser.add_argument('-o', '--output', required=False,
help="Output tasklist file")
return parser.parse_args()
args = parse_args()
frame_decoder = FallbackResponseDecorator(response_frames.FrameDecoder(response_frames.frame_factories))
upload_done = []
with open(args.downlink_frames, 'r') as downlink_frames:
for frame in downlink_frames:
f = frame_decoder.decode(ensure_byte_list(b64decode(frame.split(',')[2])[16:-2]))
if isinstance(f, response_frames.EntryProgramPartWriteSuccess):
upload_done.append((f.offset, f.size, f.entries))
upload_done = sorted(list(set(upload_done)))
print "Confirmed slots: ",
for c in upload_done:
chunk = c[0] * 1.0 / tc.WriteProgramPart.MAX_PART_SIZE
if chunk.is_integer():
chunk = int(chunk)
import pprint
import threading
from datetime import datetime
import zmq
import response_frames as rf
from utils import ensure_byte_list
Decoder = rf.FrameDecoder(rf.frame_factories)
class SessionScope(object):
def __init__(self, sender, receivers):
self.receivers = receivers
self.sender = sender
def send(self, frame):
self.sender.send(frame)
def receive_all(receivers, callback):
signal = threading.Event()
signal.clear()
started = threading.Event()
def worker():
started.set()
while True:
