def update_boot_status(self) -> (float, int):
'''
Run on boot. Updates boot count and uptime, and returns
the current boot count and previous uptime.
'''
Msg(RequestType.COMMAND_LIST,
[StorageCmd.STORE, 'LAUNCH', True]).send(SOCKET_PATH,
STORAGE_SOCKET_PATH)
# update boot count
boot_count = Msg(RequestType.COMMAND_LIST,
[StorageCmd.LOAD, 'BOOT_COUNT']).send_and_recv(
SOCKET_PATH, STORAGE_SOCKET_PATH).data
# The first time this won't be in the DB
boot_count = boot_count or 0
boot_count += 1
Msg(RequestType.COMMAND_LIST,
[StorageCmd.STORE, 'BOOT_COUNT', boot_count]).send(
SOCKET_PATH, STORAGE_SOCKET_PATH)
uptime = Msg(RequestType.COMMAND_LIST,
[StorageCmd.LOAD, 'UPTIME']).send_and_recv(
SOCKET_PATH, STORAGE_SOCKET_PATH).data
Msg(RequestType.COMMAND_LIST,
[StorageCmd.STORE, 'UPTIME', 0]).send(SOCKET_PATH,
STORAGE_SOCKET_PATH)
return uptime, boot_count
def start(self):
time.sleep(3)
low_power = Msg(RequestType.COMMAND, PowerCmd.LOW_POWER).send_and_recv(
SOCKET_PATH, POWER_SOCKET_PATH).data
try:
ground_cmd = Msg(RequestType.COMMAND,
CommsCmd.RECV_TLM_PKT).send_and_recv(
SOCKET_PATH, COMMS_SOCKET_PATH, timeout=5)
except:
# No data from ground
pass
if not low_power:
send_beacon = Msg(RequestType.COMMAND,
CommsCmd.SEND_TLM_PKT).send_and_recv(
SOCKET_PATH, COMMS_SOCKET_PATH).data
# We only want to deploy once
did_deploy = Msg(RequestType.COMMAND_LIST,
[StorageCmd.LOAD, 'DEPLOYED']).send_and_recv(
SOCKET_PATH, STORAGE_SOCKET_PATH).data
if not did_deploy:
from pfl_modes.deployment import Deployment
return Deployment
return Safe
def handle(self):
msg = pickle.loads(self.request.recv(1024))
if self.handle_default(msg):
return
if msg.data == CommsCmd.EXTEND_ANT:
result = self.deploy_antenna()
logging.info('antenna deployment result: {}'.format(result))
self.request.sendall(pickle.dumps(Msg(RequestType.DATA, result)), )
elif msg.data == CommsCmd.SEND_TLM_PKT:
result = self.beacon()
logging.info('Beacon result: {}'.format(result))
self.request.sendall(pickle.dumps(Msg(RequestType.DATA, result)))
def handle(self):
msg = pickle.loads(self.request.recv(1024))
if self.handle_default(msg):
return
if msg.data[0] == ADCSCmd.IS_TUMBLING:
result = self.is_tumbling()
self.request.sendall(pickle.dumps(Msg(RequestType.DATA, result)))
elif msg.data[0] == ADCSCmd.DETUMBLE:
result = self.detumble()
self.request.sendall(pickle.dumps(Msg(RequestType.DATA, result)))
elif msg.data[0] == ADCSCmd.POINT:
result = self.point(msg.data[1])
self.request.sendall(pickle.dumps(Msg(RequestType.DATA, result)))
def start(self):
# wait 15 mins
DEPLOY_WAIT = 1 # will actually be 15 mins
logging.info(
'Waiting {} secs to deploy antenna...'.format(DEPLOY_WAIT))
time.sleep(DEPLOY_WAIT)
# deploy antenna
# check IMU for spin decrease
self.deploy_antenna()
# update launch status
uptime, boot_count = self.update_boot_status()
logging.info('Boot count {}, previous uptime {}'.format(
boot_count, uptime))
# wait 30 mins
BEACON_WAIT = 1 # this will be 30 mins
logging.info('Waiting {} secs to begin beacon...'.format(BEACON_WAIT))
self.beacon()
# wait for ground signal
# Write status successful deployment
Msg(RequestType.COMMAND_LIST,
[StorageCmd.STORE, 'DEPLOYED', 1]).send(SOCKET_PATH,
STORAGE_SOCKET_PATH)
from pfl_modes.detumble import Detumble
return Detumble
def handle(self):
msg = pickle.loads(self.request.recv(1024))
logging.debug('{} received {} from {}'.format(SOCKET_PATH,
msg.req_type,
self.client_address))
if msg.req_type == RequestType.RESTART:
# Kill ourselves and let the watchdog restart us
raise Exception('Power going down for restart')
elif msg.req_type == RequestType.PING:
self.request.sendall(
pickle.dumps(Msg(RequestType.PING_RESP, None)), )
elif msg.req_type == RequestType.COMMAND:
print('Executing command: {}'.format(msg.data))
if msg.data == PowerCmd.LOW_POWER:
result = self.is_low_power()
self.request.sendall(
pickle.dumps(Msg(RequestType.DATA, result)))
def server_ping(server):
with FastSocket(SOCKET_PATH, server.SOCKET_PATH, timeout=60) as sock:
sock.sendall(pickle.dumps(Msg(RequestType.PING, None)))
try:
sock.recv(1024)
return True
except OSError:
return False
def start(self):
# Check IMU rates
# if low IMU
# finish detumble
# if power:
# power on mag coils
# check receiver
# if valid ground input
# finish detumble
# if timed out:
# finish detumble
# check_receiver
# record telem
# beacon
is_tumbling = Msg(
RequestType.COMMAND,
[ADCSCmd.IS_TUMBLING]
).send_and_recv(SOCKET_PATH, ADCS_SOCKET_PATH)
if not is_tumbling:
self.finish_detumble()
low_power = Msg(
RequestType.COMMAND,
PowerCmd.LOW_POWER
).send_and_recv(SOCKET_PATH, POWER_SOCKET_PATH)
if not low_power:
detumble = Msg(
RequestType.COMMAND,
[ADCSCmd.COILS_ON]
).send_and_recv(SOCKET_PATH, ADCS_SOCKET_PATH)
send_beacon = Msg(
RequestType.COMMAND,
[CommsCmd.SEND_TLM_PKT]
).send_and_recv(SOCKET_PATH, ADCS_SOCKET_PATH)
from pfl_modes.safe_mode import Safe
return Safe
def handle(self):
msg = pickle.loads(self.request.recv(MAX_FILE_SIZE))
if self.handle_default(msg):
return True
if msg.data[0] == StorageCmd.STORE:
with shelve.open(DB_PATH, 'c') as db:
# Make sure we don't have None as saved data,
# we should explicitly write zero instead
assert (msg.data[1] and msg.data[2] != None)
db[msg.data[1]] = msg.data[2]
elif msg.data[0] == StorageCmd.LOAD:
with shelve.open(DB_PATH, 'r') as db:
try:
msg = db[msg.data[1]]
except KeyError:
logging.warn('No entry {} in storage'.format(msg.data[1]))
msg = None
self.request.sendall(pickle.dumps(Msg(RequestType.DATA, msg)))
def handle_default(self, msg):
'''
Does default handling, returns true if
msg was handled
'''
logging.debug('{} received {} from {}'.format(
self.server.server_address, msg.req_type, self.client_address))
if msg.req_type == RequestType.RESTART:
# Kill ourselves and let the watchdog restart us
logging.error('{} going down for restart'.format(self.SOCKET_PATH))
self.server._BaseServer__shutdown_request = True
return True
elif msg.req_type == RequestType.PING:
self.request.sendall(
pickle.dumps(Msg(RequestType.PING_RESP, None)), )
return True
elif msg.req_type == RequestType.COMMAND:
print('Executing command: {}'.format(msg.data))
return False
elif msg.req_type == RequestType.COMMAND_LIST:
print('Executing command: {} with args {}'.format(
msg.data[0], msg.data[1:]))
return False
def beacon(self) -> bool:
return Msg(
RequestType.COMMAND,
CommsCmd.SEND_TLM_PKT,
).send_and_recv(SOCKET_PATH, COMMS_SOCKET_PATH, timeout=60 * 5)
def deploy_antenna(self) -> bool:
return Msg(
RequestType.COMMAND,
CommsCmd.EXTEND_ANT,
).send_and_recv(SOCKET_PATH, COMMS_SOCKET_PATH, timeout=60 * 5)