Hardware

An RPM simulates microgravity by continuously reorienting the sample along two perpendicular axes. On Earth, the gravitational acceleration vector always points downwards with constant magnitude and direction. By contrast, in an RPM the orientation of the sample, relative to gravity, changes rapidly and uniformly in three dimensions. This causes the direction of the gravitational vector occurring within the sample to change so rapidly over time that the particles/cells do not drift away and the net effect approaches zero when averaged over many orientations.

\begin{equation} \frac{1}{T} \int_0^T R(t)g\ dt = 0, \quad R(t): Rotation\ matrix \label{eq:sample} \end{equation}

The assumptions are that (i) the reorientation is fast enough to prevent sedimentation, (ii) slow enough to avoid centrifugal or shear artifacts, (iii) all orientations are sampled uniformly. Under these conditions, the RPM provides a functional microgravity environment without eliminating gravity itself, but by neutralizing its directional bias. Under these conditions, the RPM mimics the loss of a fixed gravity direction, reducing sedimentation and convection in small samples. However, gravity’s magnitude is unchanged, so hydrostatic pressure and weight remain, thus the machine cannot reproduce the true freefall environment of orbital microgravity [3, 5].

Given the time series where acceleration is measured for three axes \( \{t_k, a_x(t_k), a_y(t_k), a_z(t_k)\} \), at any time point, we can calculate the magnitude of the absolute acceleration to then calculate the normalized acceleration vector for each direction \( u_i(t_k) \).

$$ \|\mathbf{a}\|(t_k) = \sqrt{a_x(t_k)^2 + a_y(t_k)^2 + a_z(t_k)^2} $$

$$ u_i(t_k) = \frac{a_i(t_k)}{\|\mathbf{a}\|}, \quad i \in \{x,y,z\} $$

Since measurements are conducted on Earth, the effective gravity at any timepoint is still 1 g, but the average effective gravity over time tends toward µg.

$$ g_{\text{eff}}(n) = \sqrt{ \left( \frac{1}{n} \sum_{k=1}^{n} u_x(t_k) \right)^2 + \left( \frac{1}{n} \sum_{k=1}^{n} u_y(t_k) \right)^2 + \left( \frac{1}{n} \sum_{k=1}^{n} u_z(t_k) \right)^2 } $$

While exporting the file from Phyphox, choose CSV with the comma as the decimal separator (otherwise adjust the code).

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Add file name here
input_file = ""
output_file = "simplified.csv"
skip_step = 500

df = pd.read_csv(input_file, engine="python", sep=None, decimal=",")
time_col = df.columns[0]
b_col, c_col, d_col, e_col = df.columns[1:5]

for col in [time_col, b_col, c_col, d_col, e_col]:
    df[col] = pd.to_numeric(df[col], errors="coerce")

den = df[e_col].replace(0, np.nan)
df['F'] = df[b_col] / den
df['G'] = df[c_col] / den
df['H'] = df[d_col] / den

df['F_mean'] = df['F'].expanding().mean()
df['G_mean'] = df['G'].expanding().mean()
df['H_mean'] = df['H'].expanding().mean()

df['RMS'] = np.sqrt(df['F_mean']**2 + df['G_mean']**2 + df['H_mean']**2)

simplified_df = df[[time_col, 'RMS']].iloc[::skip_step]
simplified_df.to_csv(output_file, index=False)
print(f"Simplified data exported to: {output_file}")

plt.figure(figsize=(12, 6))
plt.scatter(simplified_df[time_col], simplified_df['RMS'], s=30,
            label=f'Every {skip_step}th Point')
plt.title("Averaged Effective Gravity Over Time")
plt.xlabel("Time [s]")
plt.ylabel("Averaged effective gravity (× g)")
plt.legend()
plt.grid(True)
plt.show()

While our RPM is already affordable, open-source, and validated, we see several opportunities to make it even more powerful for the iGEM community:

• Integrated sensors: Embed accelerometers directly into the frame for real-time monitoring and validation.
• Vibration damping: Incorporate damping mechanisms for improved stability and accuracy, though this would increase build complexity.
• specific sample holders: Develop a snap-in system compatible with various formats such as microplates, Petri dishes, and flasks, instead of relying on a universal holder.
• Enhanced motors: Use higher-quality motors without copper cables to better withstand rotational forces during long experiments. Alternatively, slip rings could mitigate this issue but this would increase the cost and complexity.

1. Drill a hole into the vessel lid using a hole saw and a drill. The hole should be the right size for your big cable gland so that the threaded side fits through the lid.

2. Unscrew the nut from the cable gland (A), insert the threaded side through the lid (B), and secure it with the nut (C).

3. Take a piece of tube. The diameter should match the cable gland or the sensor equipment you want to use. The length of the tubing depends on the depth of the vessel. Secure the tube by tightening it with the cable gland.

4. Insert the desired sensory or regulatory equipment (in our case heating element, temperature sensor, pH sensor) equipment through the tubing so that it reaches inside the bioreactor.

5. Fix everything in place inside the bioreactor using zip ties.

6. Optional: To seal the tube, you can use different methods. The quickest and easiest is to fill the tubing with silicone to create an airtight seal (if necessary) and secure any cables running through it.

7. Your bioreactor is now assembled.

Python code:

                # Raspberry Pi + ADS1115 + BPW34 photodiode
                # pip3 install adafruit-circuitpython-ads1x15

                import time
                import math
                import board
                import busio
                from adafruit_ads1x15.ads1115 import ADS1115, P0
                from adafruit_ads1x15.analog_in import AnalogIn
                import RPi.GPIO as GPIO

                # ==== Hardware setup ====
                LED_PIN = 17   # GPIO pin for LED control
                GPIO.setmode(GPIO.BCM)
                GPIO.setwarnings(False)
                GPIO.setup(LED_PIN, GPIO.OUT)
                #GPIO.output(LED_PIN, GPIO.HIGH)

                Power_PIN = 16
                GPIO.setup(Power_PIN, GPIO.OUT)
                GPIO.output(Power_PIN, GPIO.HIGH)

                i2c = busio.I2C(board.SCL, board.SDA)
                ads = ADS1115(i2c)             # ADS1115 instance
                chan = AnalogIn(ads, P0)       # Photodiode amplifier connected to A0

                # ==== Circuit parameters ====
                Vref = 1.65    # Reference voltage at op-amp non-inverting input (measure with multimeter)
                Rf = 100e3     # Feedback resistor used in transimpedance amplifier

                # ==== Helper functions ====
                def read_voltage(n=10, delay=0.01):
                    """Average 'n' voltage samples from ADS1115"""
                    s = 0.0
                    for _ in range(n):
                        s += chan.voltage
                        time.sleep(delay)
                    return s / n

                def measure_photocurrent():
                    """Measure photocurrent with LED OFF and ON, subtract ambient"""
                    # LED off baseline
                    GPIO.output(LED_PIN, GPIO.LOW)
                    time.sleep(1)
                    v_off = read_voltage(10)

                    # LED on signal
                    GPIO.output(LED_PIN, GPIO.HIGH)
                    time.sleep(1)
                    v_on = read_voltage(10)
                    
                    print(f"DEBUG: v_off={v_off:.4f} V, v_on={v_on:.4f} V")

                    # Return LED-only voltage difference
                    v_signal = max(v_on - v_off, 1e-6)   # avoid negatives or zero
                    photocurrent = (Vref - v_signal) / Rf
                    return v_signal, photocurrent

                def calc_OD(blank_current, sample_current):
                    """Calculate OD using Beer-Lambert law"""
                    if sample_current <= 0 or blank_current <= 0:
                        return None
                    return -math.log10(sample_current / blank_current)

                # ==== Calibration ====
                print("Insert blank cuvette, LED will flash to calibrate...")
                time.sleep(2)
                _, photocurrent_blank = measure_photocurrent()
                print(f"Blank photocurrent = {photocurrent_blank*1e6:.3f} uA")

                # ==== Measurement loop ====
                try:
                    while True:
                        v_sig, photocurrent = measure_photocurrent()
                        od = calc_OD(photocurrent_blank, photocurrent)
                        print(f"Signal {v_sig:.4f} V, I {photocurrent*1e6:.3f} uA, OD {od}")
                        time.sleep(0.5)

                except KeyboardInterrupt:
                    print("Exiting...")

                finally:
                    GPIO.cleanup()