def transmitter_thread(
configuration: Configuration,
start_time: float,
current_readings: AtomicBuffer,
pcnt_to_limit: AtomicValue,
continue_running: AtomicValue,
):
"""Transmit the latest data"""
try:
rfm9x = init_radio(configuration)
if not rfm9x:
return
last_check = time.time()
readings_sent = 0
while continue_running.get_value():
try:
readings_sent, last_check = transmit_latest_readings(
pcnt_to_limit,
rfm9x,
last_check,
readings_sent,
start_time,
current_readings,
)
time.sleep(0)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Transmitter failure", ex)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Transmitter failure", ex)
def test_lsm303dlh(configuration: Configuration):
"""Take a reading from the lsm303dlh to test its functionality"""
try:
logging.info("Testing lsm303dlh ...")
(mag, accel) = init_magnetometer_accelerometer(configuration)
if mag and accel:
start_time = time.time()
acceleration = (0.0, 0.0, 0.0)
magnetic = (0.0, 0.0, 0.0)
readings = 0
while time.time() - start_time < TEST_TIME_LENGTH:
acceleration = accel.acceleration
magnetic = mag.magnetic
readings += 1
total_time = time.time() - start_time
logging.info(
"Last lsm303dlh acceleration and magnetic reading: %f %f %f %f %f %f out of %d readings at an average rate of %f/sec", # pylint: disable= line-too-long
*acceleration,
*magnetic,
readings,
float(readings) / total_time,
)
else:
logging.info("No lsm303dlh hardware configured")
except Exception as ex: # pylint: disable=broad-except
handle_exception("lsm303dlh failure", ex)
def test_gps(configuration: Configuration):
"""Take a reading from the gps to test its functionality"""
try:
logging.info("Testing gps ...")
gps = init_gps(configuration)
if gps:
gps_value = AtomicValue()
start_time = time.time()
readings = 0
while readings < 10 or time.time() - start_time < TEST_TIME_LENGTH:
try:
if take_gps_reading(gps, gps_value):
readings += 1
except Exception as ex: # pylint: disable=broad-except:
handle_exception("Reading failure", ex)
total_time = time.time() - start_time
logging.info(
"Last GPS reading: %f, %f, %f, %f out of %d readings at an average rate of %f/sec",
*gps_value.get_value(),
readings,
float(readings) / total_time,
)
else:
logging.info("No GPS hardware configured")
except Exception as ex: # pylint: disable=broad-except
handle_exception("GPS failure", ex)
def test_bmp3xx(configuration: Configuration):
"""Take a reading from the bmp3xx to test its functionality"""
try:
logging.info("Testing bmp3xx ...")
bmp = init_altimeter(configuration)
if bmp:
start_time = time.time()
pressure = 0.0
temperature = 0.0
readings = 0
while time.time() - start_time < TEST_TIME_LENGTH:
(
pressure,
temperature,
) = bmp._read() # pylint: disable=protected-access
readings += 1
total_time = time.time() - start_time
logging.info(
"Last bmp3xx reading: %f %f out of %d readings at an average rate of %f/sec",
pressure,
temperature,
readings,
float(readings) / total_time,
)
else:
logging.info("No bmp3xx hardware configured")
except Exception as ex: # pylint: disable=broad-except
handle_exception("bmp3xx failure", ex)
def test_rfm9x(configuration: Configuration):
"""Transmit on the rfm9x to test its functionality"""
try:
logging.info("Testing rfm9x ...")
rfm9x = init_radio(configuration)
if rfm9x:
camera_is_running = AtomicValue(0.0)
current_reading = AtomicBuffer(2)
current_reading.put([0.0 for _ in range(TELEMETRY_TUPLE_LENGTH)])
current_reading.put([0.0 for _ in range(TELEMETRY_TUPLE_LENGTH)])
start_time = time.time()
transmissions = 0
while time.time() - start_time < TEST_TIME_LENGTH:
transmit_latest_readings(camera_is_running, rfm9x, 0, 0, 0,
current_reading)
transmissions += 1
total_time = time.time() - start_time
logging.info(
"Transmitted %d messages at an average rate of %f/sec",
transmissions,
float(transmissions) / total_time,
)
else:
logging.info("No rfm9x hardware configured")
except Exception as ex: # pylint: disable=broad-except
handle_exception("rfm9x failure", ex)
def altimeter_reading_loop(configuration: Configuration,
altimeter_value: AtomicValue):
"""Continually read the altimeter and set it to the atomic var"""
try:
bmp = init_altimeter(configuration)
while bmp:
try:
altimeter_value.update(bmp._read()) # pylint: disable=protected-access
except Exception as ex: # pylint: disable=broad-except
handle_exception("Altimeter reading failure", ex)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Altimeter setup failure", ex)
def sensor_reading_loop(*args):
"""Read from the sensors on and infinite loop and queue it for transmission and logging"""
try:
logging.info("Starting sensor measurement loop")
while True:
try:
digest_next_sensor_reading(*args)
time.sleep(0.03)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Telemetry measurement point reading failure",
ex)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Telemetry measurement point reading failure", ex)
def camera_thread(configuration: Configuration, start_time: float):
"""Start the camera and log the video"""
try:
logging.info("Starting video capture")
runtime_limit = configuration.get("runtime_limit")
output_directory = configuration.get("output_directory")
camera = picamera.PiCamera(framerate=90)
camera.start_recording(
os.path.join(output_directory, f"video_{int(start_time)}.h264"))
camera.wait_recording(runtime_limit)
camera.stop_recording()
logging.info("Video capture complete")
except Exception as ex: # pylint: disable=broad-except
handle_exception("Video capture failure", ex)
def sensor_log_writing_loop(configuration: Configuration, start_time: float,
data_queue: Queue):
"""Loop through clearing the data queue until RUNTIME_LIMIT has passed"""
try:
logging.info("Starting sensor log writing loop")
runtime_limit = configuration.get("runtime_limit")
output_directory = configuration.get("output_directory")
with open(
os.path.join(output_directory,
f"sensor_log_{int(start_time)}.csv"),
"w") as outfile:
write_sensor_log(start_time, runtime_limit, outfile, data_queue)
logging.info("Telemetry log writing loop complete")
except Exception as ex: # pylint: disable=broad-except
handle_exception("Telemetry log line writing failure", ex)
def magnetometer_accelerometer_reading_loop(
configuration: Configuration,
magnetometer_accelerometer_value: AtomicValue):
"""Continually read the accelerometer/magnetometer and set it to the atomic var"""
try:
mag, accel = init_magnetometer_accelerometer(configuration)
while mag and accel:
try:
magnetometer_accelerometer_value.update(
(*accel.acceleration, *mag.magnetic))
except Exception as ex: # pylint: disable=broad-except
handle_exception("Magnetometer/Accelerometer reading failure",
ex)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Magnetometer/Accelerometer setup failure", ex)
def telemetry_reception_loop(configuration: Configuration,
new_data_queue: Queue, gps_value: AtomicValue):
"""Loop forever reading telemetry and passing to the processing queue"""
try:
logging.info("Starting telemetry reading loop")
rfm9x = init_radio(configuration)
if not rfm9x:
return
while True:
try:
digest_next_ground_reading(rfm9x, new_data_queue, gps_value)
time.sleep(0)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Telemetry point reading failure", ex)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Telemetry point reading failure", ex)
def replay_telemetry(new_data_queue: Queue, replay_file: str):
"""Replays telemetry from a file"""
try:
while True:
start_time = time.time()
logging.info("Replaying telemetry from %d", replay_file)
with open(replay_file, "r") as file:
reader = csv.reader(file)
start_stamp = None
for row in reader:
info = [float(v) for v in row]
if not start_stamp:
start_stamp = info[0]
while time.time() - start_time < info[0] - start_stamp:
pass
new_data_queue.put(info)
time.sleep(0)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Telemetry replay failure", ex)
def camera_thread(
configuration: Configuration,
start_time: float,
continue_running: AtomicValue,
continue_logging: AtomicValue,
):
"""Start the camera and log the video"""
try:
logging.info("Starting video capture")
output_directory = configuration.get("output_directory")
camera = picamera.PiCamera(framerate=90)
camera.start_recording(
os.path.join(output_directory, f"video_{int(start_time)}.h264")
)
while continue_running.get_value() and continue_logging.get_value():
time.sleep(5)
camera.stop_recording()
logging.info("Video capture complete")
except Exception as ex: # pylint: disable=broad-except
handle_exception("Video capture failure", ex)
def write_sensor_log(start_time: float, runtime_limit: float, outfile,
data_queue: Queue):
"""Write the queue to the log for a specified period"""
lines_written = 0
last_queue_check = time.time()
while time.time() - start_time <= runtime_limit:
try:
if write_queue_log(outfile, data_queue, None):
lines_written += 1
if last_queue_check + 10.0 < time.time():
last_queue_check = time.time()
elapsed = last_queue_check - start_time
logging.info(
"Queue: %d / Lines written: %d / %s seconds",
data_queue.qsize(),
lines_written,
elapsed,
)
time.sleep(0)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Telemetry log line writing failure", ex)
def sensor_log_writing_loop(
configuration: Configuration,
start_time: float,
data_queue: Queue,
continue_running: AtomicValue,
continue_logging: AtomicValue,
):
"""Loop through clearing the data queue until cancelled"""
try:
logging.info("Starting sensor log writing loop")
output_directory = configuration.get("output_directory")
with open(
os.path.join(output_directory, f"sensor_log_{int(start_time)}.csv"),
"w",
encoding="utf8",
) as outfile:
write_sensor_log(
start_time, outfile, data_queue, continue_running, continue_logging
)
logging.info("Telemetry log writing loop complete")
except Exception as ex: # pylint: disable=broad-except
handle_exception("Telemetry log line writing failure", ex)
def transmitter_thread(configuration: Configuration, start_time: float,
current_reading: AtomicValue):
"""Transmit the latest data"""
try:
rfm9x = init_radio(configuration)
if not rfm9x:
return
last_check = time.time()
readings_sent = 0
while True:
try:
readings_sent, last_check = transmit_latest_readings(
rfm9x,
last_check,
readings_sent,
start_time,
current_reading,
)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Transmitter failure", ex)
time.sleep(0)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Transmitter failure", ex)
def telemetry_log_writing_loop(new_data_queue: Queue,
buffer_session_store: BufferSessionStore):
"""Loop forever clearing the data queue"""
try:
logging.info("Starting telemetry log writing loop")
while not buffer_session_store.current_session.get_value():
time.sleep(1)
while True:
start_time = buffer_session_store.current_session.get_value()
with open(buffer_session_store.data_path_for_session(),
"w") as outfile:
while True:
try:
write_queue_log(outfile, new_data_queue,
buffer_session_store)
time.sleep(0)
if (start_time != buffer_session_store.current_session.
get_value()):
break
except Exception as ex: # pylint: disable=broad-except
handle_exception("Telemetry log line writing failure",
ex)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Telemetry log line writing failure", ex)
def sensor_reading_loop(
configuration: Configuration,
start_time: float,
data_queue: Queue,
current_readings: AtomicBuffer,
gps_value: AtomicValue,
continue_running: AtomicValue,
):
"""Read from the sensors on and infinite loop and queue it for transmission and logging"""
try:
logging.info("Starting sensor measurement loop")
bmp = init_altimeter(configuration)
mag, accel = init_magnetometer_accelerometer(configuration)
start = time.time()
readings = 0.0
while continue_running.get_value():
try:
digest_next_sensor_reading(
start_time,
data_queue,
current_readings,
gps_value.get_value(),
bmp._read(), # pylint: disable=protected-access
(*accel.acceleration, *mag.magnetic),
)
readings += 1.0
now = time.time()
if now - start > 10:
readings_per_second = readings / (now - start)
logging.info("Sample rate: %f/s", readings_per_second)
start = time.time()
readings = 0
except Exception as ex: # pylint: disable=broad-except
handle_exception("Telemetry measurement point reading failure", ex)
except Exception as ex: # pylint: disable=broad-except
handle_exception("Telemetry measurement point reading failure", ex)
