def run(self):
self.logger.debug("run")
telemetry = {}
telemCoef = {
'SatCount': 1,
'outside_temp': 10,
'inside_temp': 10,
'barometer': 1,
'battery': 100
}
exitFlag = False
self.prev_gps_status = ""
while not exitFlag:
try:
# blink
self.ledState = 1 - self.ledState
GPIO.output(self.config['pins']['LED1'], GPIO.HIGH)
watchdog = Watchdog(60)
# gps
self.gps.loop()
gpsdata = self.gps.get_data()
self.calc_balloon_state(gpsdata)
if gpsdata['status'] == "fix" and gpsdata['alt'] > 0:
self.sensors.calibrate_alt(gpsdata['alt'])
if gpsdata['status'] != "fix":
gpsdata['alt'] = self.sensors.read_pressure()
# sensors
sensordata = self.sensors.get_data()
sensordata.update(self.cam.status)
status_bits = self.calc_status_bits(gpsdata, sensordata)
telemetry[
'Satellites'] = gpsdata['SatCount'] * telemCoef['SatCount']
telemetry['outside_temp'] = sensordata[
'outside_temp'] * telemCoef['outside_temp']
telemetry['inside_temp'] = sensordata[
'inside_temp'] * telemCoef['inside_temp']
telemetry['barometer'] = sensordata['barometer'] * telemCoef[
'barometer']
telemetry[
'battery'] = sensordata['battery'] * telemCoef['battery']
if gpsdata['status'] != self.prev_gps_status:
frame = self.aprs.create_telem_data_msg(
telemetry, status_bits, gpsdata['alt'])
self.modem.encode(frame)
self.modem.saveToFile(
os.path.join(self.tmp_dir, 'aprs.wav'))
self.radio_queue(self.config['frequencies']['APRS'],
os.path.join(self.tmp_dir, 'aprs.wav'))
self.prev_gps_status = gpsdata['status']
# UI
self.webserver.update(gpsdata, sensordata, self.state)
self.update_system_datetime(gpsdata)
if self.timers.expired("APRS"):
if gpsdata['status'] == "fix":
self.logger.debug("sending location")
frame = self.aprs.create_location_msg(
gpsdata, telemetry, status_bits)
else:
self.logger.debug("sending only telemetry")
frame = self.aprs.create_telem_data_msg(
telemetry, status_bits, gpsdata['alt'])
self.modem.encode(frame)
self.modem.saveToFile(
os.path.join(self.tmp_dir, 'aprs.wav'))
self.radio_queue(self.config['frequencies']['APRS'],
os.path.join(self.tmp_dir, 'aprs.wav'))
with open(os.path.join(self.tmp_dir, "flight.log"),
'a+') as f:
merged = dict()
merged.update(gpsdata)
merged.update(sensordata)
merged['datatime'] = datetime.datetime.now().isoformat(
)
f.write(json.dumps(merged, indent=2))
f.write(',\n')
if self.timers.expired("APRS-META"):
frame = self.aprs.create_telem_name_msg(
telemetry, self.status_names)
self.modem.encode(frame)
self.modem.saveToFile(
os.path.join(self.tmp_dir, 'aprs.wav'))
self.radio_queue(self.config['frequencies']['APRS'],
os.path.join(self.tmp_dir, 'aprs.wav'))
frame = self.aprs.create_telem_eqns_msg(telemCoef)
self.modem.encode(frame)
self.modem.saveToFile(
os.path.join(self.tmp_dir, 'coef.wav'))
self.radio_queue(self.config['frequencies']['APRS'],
os.path.join(self.tmp_dir, 'coef.wav'))
if self.timers.expired("Capture"):
self.capture_image()
if self.timers.expired("Snapshot"):
self.imaging_counter += 1
cam_select = self.imaging_counter % CAMERAS
self.capture_image(archive=False)
self.prep_image(cam_select, gpsdata, sensordata)
self.webserver.snapshot()
if self.timers.expired("Imaging"):
self.imaging_counter += 1
cam_select = self.imaging_counter % CAMERAS
cam_system = self.imaging_counter % (CAMERAS + 1)
self.logger.info("imageing trigger")
self.logger.debug("cam %s system %s" %
(cam_select, cam_system))
self.capture_image(archive=False)
self.prep_image(cam_select, gpsdata, sensordata)
self.webserver.snapshot()
if cam_system == 0:
self.logger.info("->sstv")
_thread.start_new_thread(self.process_sstv, ())
else:
self.logger.info("->ssdv")
_thread.start_new_thread(self.process_ssdv, ())
if self.timers.expired("PLAY-SSDV"):
self.logger.debug("sending ssdv")
self.radio_queue(self.config['frequencies']['APRS'],
os.path.join("data", 'starting_ssdv.wav'))
self.radio_queue(self.config['frequencies']['APRS'],
os.path.join("data", 'habhub.wav'))
self.radio_queue(self.config['frequencies']['APRS'],
os.path.join(self.tmp_dir, 'ssdv.wav'))
if self.timers.expired("PLAY-SSTV"):
self.logger.debug("sending sstv")
self.radio_queue(
self.config['frequencies']['APRS'],
os.path.join("data", 'switching_to_sstv.wav'))
self.radio_queue(self.config['frequencies']['SSTV'],
os.path.join("data", 'starting_sstv.wav'))
self.radio_queue(self.config['frequencies']['SSTV'],
os.path.join(self.tmp_dir, 'sstv.wav'))
if self.timers.expired("Buzzer"):
for i in range(3):
GPIO.output(self.config['pins']['BUZZER'], GPIO.HIGH)
time.sleep(0.5)
GPIO.output(self.config['pins']['BUZZER'], GPIO.LOW)
time.sleep(0.5)
GPIO.output(self.config['pins']['LED1'], GPIO.LOW)
watchdog.stop()
time.sleep(1)
except Watchdog:
self.logger.error("task timedout!")
except KeyboardInterrupt: # If CTRL+C is pressed, exit cleanly
exitFlag = True
self.gps.stop()
break
except Exception as x:
self.logger.exception(x)
self.logger.info("Done.")
from pinball import Pinball, switch_controller
SOLENOID_CONTROLLER_ADDRESS = 0x20
try:
watchdog = None
from watchdog import Watchdog
except:
logger.warn("[!] Watchdog not imported")
else:
watchdog = Watchdog(SOLENOID_CONTROLLER_ADDRESS) # watchdog to make sure the solenoids don't stay on too long
watchdog.start()
def main():
pinball_game = Pinball()
pinball_game.start()
if __name__ == '__main__':
try:
main()
except Exception as ex:
logger.critical(ex)
switch_controller.stop_listening()
if watchdog != None:
watchdog.stop()
exit()
stateMachine.add_state("RESPONDING_TO_NEW_WORD", respondToNewWord);
stateMachine.add_state("PUBLISHING_WORD", publishWord);
stateMachine.add_state("PUBLISHING_LETTER", publishShape);
stateMachine.add_state("WAITING_FOR_LETTER_TO_FINISH", waitForShapeToFinish);
stateMachine.add_state("ASKING_FOR_FEEDBACK", askForFeedback);
stateMachine.add_state("WAITING_FOR_FEEDBACK", waitForFeedback);
stateMachine.add_state("RESPONDING_TO_FEEDBACK", respondToFeedback);
stateMachine.add_state("RESPONDING_TO_DEMONSTRATION", respondToDemonstration);
stateMachine.add_state("RESPONDING_TO_TEST_CARD", respondToTestCard);
#stateMachine.add_state("RESPONDING_TO_TABLET_DISCONNECT", respondToTabletDisconnect);
stateMachine.add_state("WAITING_FOR_TABLET_TO_CONNECT", waitForTabletToConnect);
stateMachine.add_state("STOPPING", stopInteraction);
stateMachine.add_state("EXIT", None, end_state=True);
stateMachine.set_start("WAITING_FOR_ROBOT_TO_CONNECT");
infoForStartState = {'state_goTo': ["STARTING_INTERACTION"], 'state_cameFrom': None};
wordToLearn = args.word;
if(wordToLearn is not None):
message = String();
message.data = wordToLearn;
onWordReceived(message);
else:
print('Waiting for word to write');
stateMachine.run(infoForStartState);
rospy.spin();
tabletWatchdog.stop();
robotWatchdog.stop();
class BittrexSocket:
__hub = None
__invoke_event = None
__invoke_resp = None
__watchdog: Optional[Watchdog]
__invoke_lock = Optional[asyncio.Lock]
__connection: Optional[Connection]
def __init__(self, api_key=None, api_secret=None):
self.api_key = api_key
self.api_secret = api_secret
async def listen(self, channels: list[str], callbacks: dict[str,
Callable]):
self.__watchdog = Watchdog(HEARTBEAT_TIMEOUT)
self.__invoke_lock = asyncio.Lock()
await self.__connect()
if self.api_key is not None:
await self.__auth()
assert 'heartbeat' not in channels
channels.append('heartbeat')
callbacks['heartbeat'] = self.__on_heartbeat
await self.__subscribe(channels, callbacks)
await self.__watchdog.loop()
self.__connection.close()
async def __on_heartbeat(self, _):
self.__watchdog.reset()
async def __connect(self):
self.__connection = Connection(URL)
self.__hub = self.__connection.register_hub('c3')
self.__connection.received += self.__on_message
self.__connection.error += self.__on_error
self.__connection.start()
log.info(f'Connected')
async def __on_message(self, **msg):
if 'R' in msg:
self.__invoke_resp = msg['R']
self.__invoke_event.set()
def stop(self):
self.__watchdog.stop()
async def __on_error(self, msg):
log.error(str(msg))
self.stop()
async def __auth(self):
timestamp = str(int(time.time()) * 1000)
random_content = str(uuid.uuid4())
content = timestamp + random_content
signed_content = hmac.new(self.api_secret.encode(), content.encode(),
hashlib.sha512).hexdigest()
response = await self.__invoke('Authenticate', self.api_key, timestamp,
random_content, signed_content)
if response['Success']:
log.info(f'Authenticated')
async def reauth(_):
asyncio.create_task(self.__auth())
self.__hub.client.on('authenticationExpiring', reauth)
else:
log.error(f'Authentication failed: {response["ErrorCode"]}')
async def __subscribe(self, channels, callbacks):
for method, callback in callbacks.items():
self.__hub.client.on(
method,
corotools.wraptry(corotools.wrapfunc(callback,
self.__decode_message),
msg='BittrexSocket callback exception'))
response = await self.__invoke('Subscribe', channels)
for i in range(len(channels)):
if response[i]['Success']:
log.info(f'Subscription to "{channels[i]}" successful')
else:
log.error(
f'Subscription to "{channels[i]}" failed: {response[i]["ErrorCode"]}'
)
self.stop()
async def __invoke(self, method, *args):
async with self.__invoke_lock:
self.__invoke_event = asyncio.Event()
self.__hub.server.invoke(method, *args)
await self.__invoke_event.wait()
return self.__invoke_resp
@staticmethod
def __decode_message(msg):
if not len(msg):
return None
else:
msg = msg[0]
try:
decompressed_msg = decompress(b64decode(msg, validate=True),
-MAX_WBITS)
except SyntaxError:
decompressed_msg = decompress(b64decode(msg, validate=True))
return json.loads(decompressed_msg.decode())
