Flying Laptop: a month of measured solar-array generation#

Use the public orbitalpv API to download calibrated, real on-orbit voltage and current measurements from the University of Stuttgart’s Flying Laptop satellite. February 2018 contains 75,097 packet timestamps and 300,388 array observations across right, left, center and experimental test arrays.

Install pip install "orbital-pv[examples]". The first run downloads one 30 MB compressed monthly archive; subsequent runs reuse it. The connector reads only electrical packet 4900 inside the archive without extracting files to disk. No interpolation or synthetic records are added.

Source and interpretation#

The source timestamps are UTC packet-generation times, expressed as Unix epoch milliseconds. They are not radio reception times. The official data description allows up to 400 ms between sensor acquisition and packet timing. The packet supplies calibrated voltages in V and currents in A; electrical power below is computed as their product rather than independently measured.

The test channel is an experimental array channel aboard the spacecraft, not a ground-test session. Small signed sensor offsets are retained. Recorded values describe the operating system and do not, by themselves, establish maximum-power capability, irradiance-normalized efficiency or degradation.

from __future__ import annotations

from pathlib import Path
from tempfile import gettempdir

import matplotlib.dates as mdates
import matplotlib.pyplot as plt
import pandas as pd

import orbitalpv as opv

The local loader verifies the download’s checksum sidecar when present. Every packet contributes four array observations. Missing values are omitted per voltage/current pair rather than replaced with zeros.

cache = Path(gettempdir()) / "orbitalpv-real-data"
archive = cache / "FLP_TM_HK_2018-02.tar.bz2"
if archive.exists():
    telemetry = opv.load_flying_laptop_power(archive)
else:
    telemetry = opv.fetch_flying_laptop_power("2018-02", archive)

times = telemetry["timestamp"].drop_duplicates().sort_values()
gaps = times.diff().dt.total_seconds()
print(f"Packet timestamps: {len(times):,}")
print(f"Array observations: {len(telemetry):,}")
print(f"UTC packet coverage: {times.min()} to {times.max()}")
print(f"Median interval: {gaps.median():.3f} s; largest gap: {gaps.max():.3f} s")
print(f"Source DOI: {telemetry.attrs['dataset_doi']}")
print(f"Archive SHA256: {telemetry.attrs['sha256']}")

daily_counts = times.groupby(times.dt.floor("D")).size()
fig, ax = plt.subplots(figsize=(10, 4), layout="constrained")
ax.bar(daily_counts.index, daily_counts.values, width=0.8, color="#586A83")
ax.set(
    title="Step 1 — Recorded Flying Laptop packets per day",
    xlabel="UTC date",
    ylabel="Unique packet timestamps",
)
ax.xaxis.set_major_locator(mdates.DayLocator(interval=4))
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d %b"))
ax.grid(True, axis="y", alpha=0.25)
plt.show()
Step 1 — Recorded Flying Laptop packets per day
Packet timestamps: 75,097
Array observations: 300,388
UTC packet coverage: 2018-02-01 00:00:11.952000+00:00 to 2018-02-28 23:59:25.624000+00:00
Median interval: 30.150 s; largest gap: 663.300 s
Source DOI: 10.18419/darus-451
Archive SHA256: 9ec01cfc3128cc4dad522df14cb4aa73191748791a8677e181e4ed4c6e2af1bb

All samples in this interval are displayed; discrete markers avoid drawing invented values across telemetry gaps. Array identities come from the official packet-4900 definitions, rather than inferred column positions.

start = times.min().normalize()
stop = start + pd.Timedelta(hours=6)
detail = telemetry[(telemetry["timestamp"] >= start) & (telemetry["timestamp"] < stop)]
colors = {"right": "#0072B2", "left": "#D55E00", "center": "#009E73", "test": "#CC79A7"}
print(f"Detailed interval: {start} to {stop} (end excluded)")
print(f"Detailed native packet timestamps: {detail['timestamp'].nunique():,}")


def plot_native(column: str, ylabel: str, title: str) -> None:
    """Plot every supplied observation in the selected recording interval."""
    _fig, ax = plt.subplots(figsize=(10, 4.3), layout="constrained")
    for panel_id, panel in detail.groupby("panel_id", sort=True):
        ax.plot(
            panel["timestamp"],
            panel[column],
            ".",
            ms=2.5,
            alpha=0.7,
            color=colors[str(panel_id)],
            label=str(panel_id),
        )
    ax.set(title=title, xlabel="UTC packet time on 1 February 2018", ylabel=ylabel)
    ax.xaxis.set_major_locator(mdates.HourLocator())
    ax.xaxis.set_major_formatter(mdates.DateFormatter("%H:%M"))
    ax.grid(True, alpha=0.25)
    ax.legend(title="Array", loc="upper left", bbox_to_anchor=(1.01, 1))
    plt.show()


plot_native("voltage_v", "Measured array voltage [V]", "Step 2 — Calibrated array voltages")
Step 2 — Calibrated array voltages
Detailed interval: 2018-02-01 00:00:00+00:00 to 2018-02-01 06:00:00+00:00 (end excluded)
Detailed native packet timestamps: 717

Array currents are already in amperes. Low-current periods remain part of the record; they are not automatically labeled as eclipses or faults.

plot_native("current_a", "Measured array current [A]", "Step 3 — Calibrated array currents")
Step 3 — Calibrated array currents

The connector computes power_w = voltage_v * current_a in each packet. Current and voltage belong to the same array and housekeeping packet; no nearest-neighbor matching across different telemetry streams is needed.

plot_native("power_w", "Array power from V x I [W]", "Step 4 — Observed solar-array generation")
Step 4 — Observed solar-array generation

Daily P95 values use all available observations and summarize operating behavior, including changing illumination, attitude and power-system state. They are not a degradation estimate. Coverage varies, so the counts in the first figure should be considered alongside these daily summaries.

daily = (
    telemetry.assign(day=telemetry["timestamp"].dt.floor("D"))
    .groupby(["panel_id", "day"], as_index=False)
    .agg(power_p95_w=("power_w", lambda values: float(values.quantile(0.95))))
)
fig, ax = plt.subplots(figsize=(10, 4.3), layout="constrained")
for panel_id, panel in daily.groupby("panel_id", sort=True):
    ax.scatter(
        panel["day"], panel["power_p95_w"], s=25, color=colors[str(panel_id)], label=str(panel_id)
    )
ax.set(
    title="Step 5 — Daily P95 of observed array power",
    xlabel="UTC date",
    ylabel="Daily 95th-percentile power [W]",
)
ax.xaxis.set_major_locator(mdates.DayLocator(interval=4))
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d %b"))
ax.grid(True, alpha=0.25)
ax.legend(title="Array", loc="upper left", bbox_to_anchor=(1.01, 1))
plt.show()
Step 5 — Daily P95 of observed array power

This dataset adds a month-scale history of genuine spacecraft electrical measurements, with recorded gaps. Use the full connector time filters to select other intervals. Before interpreting changes as physical degradation, add independently verified geometry, attitude, irradiance and operating-state information. Do not integrate straight across data gaps to claim a complete mission energy yield.

Total running time of the script: (0 minutes 5.716 seconds)

Gallery generated by Sphinx-Gallery